entityops

var (
	// ErrSchemaNotFound indicates the schema name could not be resolved
	ErrSchemaNotFound = errors.New("entityops: schema not found")
	// ErrCreateFailed indicates an entity creation failed
	ErrCreateFailed = errors.New("entityops: create failed")
	// ErrUpdateFailed indicates an entity update failed
	ErrUpdateFailed = errors.New("entityops: update failed")
	// ErrQueryFailed indicates an entity query failed
	ErrQueryFailed = errors.New("entityops: query failed")
	// ErrLoadFailed indicates an entity load failed
	ErrLoadFailed = errors.New("entityops: load failed")
	// ErrLinkFailed indicates an edge link operation failed
	ErrLinkFailed = errors.New("entityops: link failed")
	// ErrEdgeNotFound indicates the named edge does not exist or is not linkable on the source schema
	ErrEdgeNotFound = errors.New("entityops: edge not found")
	// ErrDecodeFailed indicates input JSON decoding failed
	ErrDecodeFailed = errors.New("entityops: decode failed")
	// ErrMarshalFailed indicates entity JSON marshaling failed
	ErrMarshalFailed = errors.New("entityops: marshal failed")
	// ErrEmitFailed indicates a gala event emission failed
	ErrEmitFailed = errors.New("entityops: emit failed")
	// ErrPersistFailed indicates a generic persistence failure
	ErrPersistFailed = errors.New("entityops: persist failed")
	// ErrValidationFailed indicates the input did not satisfy schema constraints
	ErrValidationFailed = errors.New("entityops: validation failed")
	// ErrUpsertConflict indicates an upsert matched more than one existing record
	ErrUpsertConflict = errors.New("entityops: upsert conflict")
	// ErrUpsertKeyMissing indicates the payload omitted the schema's lookup key value
	ErrUpsertKeyMissing = errors.New("entityops: upsert key missing")
	// ErrUpsertUnsupported indicates the schema does not support catalog-driven upserts
	ErrUpsertUnsupported = errors.New("entityops: upsert unsupported")
	// ErrFieldNotFound indicates a field name could not be resolved on the schema
	ErrFieldNotFound = errors.New("entityops: field not found")
	// ErrValueCoercion indicates a raw value could not be coerced to the field's type
	ErrValueCoercion = errors.New("entityops: value coercion failed")
	// ErrListenerRegistrationFailed indicates a gala listener could not be registered
	ErrListenerRegistrationFailed = errors.New("entityops: listener registration failed")
	// ErrMutationListenerInvalid indicates a listener is missing its schema or handler
	ErrMutationListenerInvalid = errors.New("entityops: invalid mutation listener")
	// ErrNotifySpecInvalid indicates a notify spec is missing recipients or content
	ErrNotifySpecInvalid = errors.New("entityops: notify spec requires recipients, type, topic, and title and body templates")
	// ErrMutationSchemaMismatch indicates a payload was delivered to a listener for another schema
	ErrMutationSchemaMismatch = errors.New("entityops: mutation schema mismatch")
	// ErrClientResolveFailed indicates the ent client could not be resolved from the injector
	ErrClientResolveFailed = errors.New("entityops: client resolve failed")
	// ErrQueryUnsupported indicates the schema does not support org-scoped queries
	ErrQueryUnsupported = errors.New("entityops: query unsupported")
	// ErrEvaluationFailed indicates a CEL expression evaluation failed
	ErrEvaluationFailed = errors.New("entityops: evaluation failed")
	// ErrKeyMatchUnsupported indicates the schema does not support key-based target queries
	ErrKeyMatchUnsupported = errors.New("entityops: key match unsupported")
	// ErrInvalidKeyField indicates a key match referenced a field that is not an indexable key on the schema
	ErrInvalidKeyField = errors.New("entityops: invalid key field")
	// ErrEvaluatorBuildFailed indicates the typed CEL evaluator for a schema projection could not be built
	ErrEvaluatorBuildFailed = errors.New("entityops: evaluator build failed")
	// ErrIngestUnsupported indicates the schema has no generated ingest capability
	ErrIngestUnsupported = errors.New("entityops: ingest unsupported")
	// ErrIngestMisconfigured indicates a schema ingest capability was wired incorrectly at startup:
	// bound without persistence, bound twice, or registered without its resolver or binding
	ErrIngestMisconfigured = errors.New("entityops: ingest misconfigured")
	// ErrIngestIntegrationResolveFailed indicates the durable command's integration could not be resolved
	ErrIngestIntegrationResolveFailed = errors.New("entityops: ingest integration resolve failed")
)

var (
	// OpCreate is the create mutation operation
	OpCreate = ent.OpCreate.String()
	// OpUpdate is the bulk update mutation operation
	OpUpdate = ent.OpUpdate.String()
	// OpUpdateOne is the single-row update mutation operation
	OpUpdateOne = ent.OpUpdateOne.String()
	// OpDelete is the bulk hard-delete mutation operation
	OpDelete = ent.OpDelete.String()
	// OpDeleteOne is the single-row hard-delete mutation operation
	OpDeleteOne = ent.OpDeleteOne.String()
)

var (
	SchemaAPIToken = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "APIToken",
			Snake: "api_token",
			Lower: "apitoken",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "api_token", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.APIToken.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaActionPlan = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "ActionPlan",
			Snake:            "action_plan",
			Lower:            "actionplan",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[ActionPlanProjection](),
		MentionSpec:    &MentionSpec{Schema: "ActionPlan", NameField: "name", DetailsField: "details", DetailsJSONField: "details_json", OwnerField: "owner_id"},
		ApprovalSpec:   &ApprovalSpec{Schema: "ActionPlan", StatusField: "status", ApproverField: "approver_id"},
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "action_plan", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateActionPlanInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.ActionPlan.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "action_plan", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateActionPlanInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.ActionPlan.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "action_plan", Operation: refOpQuery}

			entities, err := client.ActionPlan.Query().
				Where(actionplan.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "action_plan", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.ActionPlan.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.ActionPlan.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "action_plan", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "action_plan.ingest.requested"),
			prepare: func(ctx context.Context, _ *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "action_plan", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateActionPlanInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaAssessment = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Assessment",
			Snake:            "assessment",
			Lower:            "assessment",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[AssessmentProjection](),
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "assessment", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateAssessmentInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Assessment.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "assessment", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Assessment.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Assessment.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "assessment", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaAssessmentResponse = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "AssessmentResponse",
			Snake:            "assessment_response",
			Lower:            "assessmentresponse",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[AssessmentResponseProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "assessment_response", Operation: refOpQuery}

			entities, err := client.AssessmentResponse.Query().
				Where(assessmentresponse.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "assessment_response", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.AssessmentResponse.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.AssessmentResponse.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "assessment_response", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaAsset = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Asset",
			Snake: "asset",
			Lower: "asset",
		},
		ProjectionType: reflect.TypeFor[AssetProjection](),
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "asset", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateAssetInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.Asset.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "asset", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateAssetInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Asset.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "asset", Operation: refOpQuery}

			entities, err := client.Asset.Query().
				Where(asset.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "asset", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Asset.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "asset.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "asset", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateAssetInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
					if input.IntegrationID == nil && integration.ID != "" {
						input.IntegrationID = &integration.ID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaCampaign = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Campaign",
			Snake:            "campaign",
			Lower:            "campaign",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[CampaignProjection](),
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "campaign", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateCampaignInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Campaign.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "campaign", Operation: refOpQuery}

			entities, err := client.Campaign.Query().
				Where(campaign.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "campaign", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Campaign.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Campaign.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "campaign", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaCampaignTarget = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "CampaignTarget",
			Snake:            "campaign_target",
			Lower:            "campaigntarget",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[CampaignTargetProjection](),
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "campaign_target", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateCampaignTargetInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.CampaignTarget.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "campaign_target", Operation: refOpQuery}

			entities, err := client.CampaignTarget.Query().
				Where(campaigntarget.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "campaign_target", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.CampaignTarget.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.CampaignTarget.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "campaign_target", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaCheckResult = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "CheckResult",
			Snake: "check_result",
			Lower: "checkresult",
		},
		ProjectionType: reflect.TypeFor[CheckResultProjection](),
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "check_result", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateCheckResultInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.CheckResult.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "check_result", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateCheckResultInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.CheckResult.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "check_result", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.CheckResult.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "check_result.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "check_result", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateCheckResultInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.IntegrationID == nil && integration.ID != "" {
						input.IntegrationID = &integration.ID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaContact = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Contact",
			Snake: "contact",
			Lower: "contact",
		},
		ProjectionType: reflect.TypeFor[ContactProjection](),
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "contact", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateContactInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.Contact.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "contact", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateContactInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Contact.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "contact", Operation: refOpQuery}

			entities, err := client.Contact.Query().
				Where(contact.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "contact", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Contact.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "contact.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "contact", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateContactInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.IntegrationID == nil && integration.ID != "" {
						input.IntegrationID = &integration.ID
					}
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaControl = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Control",
			Snake:            "control",
			Lower:            "control",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[ControlProjection](),
		ConsoleRoute:   &ConsoleRoute{Base: "controls"},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "control", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateControlInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Control.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "control", Operation: refOpQuery}

			entities, err := client.Control.Query().
				Where(control.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "control", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Control.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Control.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "control", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaControlImplementation = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "ControlImplementation",
			Snake: "control_implementation",
			Lower: "controlimplementation",
		},
		ProjectionType: reflect.TypeFor[ControlImplementationProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "control_implementation", Operation: refOpQuery}

			entities, err := client.ControlImplementation.Query().
				Where(controlimplementation.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "control_implementation", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.ControlImplementation.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaControlObjective = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "ControlObjective",
			Snake: "control_objective",
			Lower: "controlobjective",
		},
		ProjectionType: reflect.TypeFor[ControlObjectiveProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "control_objective", Operation: refOpQuery}

			entities, err := client.ControlObjective.Query().
				Where(controlobjective.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "control_objective", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.ControlObjective.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaCustomDomain = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "CustomDomain",
			Snake: "custom_domain",
			Lower: "customdomain",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "custom_domain", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.CustomDomain.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaCustomTypeEnum = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "CustomTypeEnum",
			Snake: "custom_type_enum",
			Lower: "customtypeenum",
		},
		ProjectionType: reflect.TypeFor[CustomTypeEnumProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "custom_type_enum", Operation: refOpQuery}

			entities, err := client.CustomTypeEnum.Query().
				Where(customtypeenum.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "custom_type_enum", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.CustomTypeEnum.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaDNSVerification = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "DNSVerification",
			Snake: "dns_verification",
			Lower: "dnsverification",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "dns_verification", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.DNSVerification.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaDirectoryAccount = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "DirectoryAccount",
			Snake: "directory_account",
			Lower: "directoryaccount",
		},
		ProjectionType: reflect.TypeFor[DirectoryAccountProjection](),
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "directory_account", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateDirectoryAccountInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.DirectoryAccount.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "directory_account", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateDirectoryAccountInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.DirectoryAccount.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "directory_account", Operation: refOpQuery}

			entities, err := client.DirectoryAccount.Query().
				Where(directoryaccount.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "directory_account", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.DirectoryAccount.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "directory_account.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "directory_account", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateDirectoryAccountInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
					if input.IntegrationID == nil && integration.ID != "" {
						input.IntegrationID = &integration.ID
					}
					if input.PlatformID == nil && integration.PlatformID != "" {
						input.PlatformID = &integration.PlatformID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaDirectoryGroup = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "DirectoryGroup",
			Snake: "directory_group",
			Lower: "directorygroup",
		},
		ProjectionType: reflect.TypeFor[DirectoryGroupProjection](),
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "directory_group", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateDirectoryGroupInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.DirectoryGroup.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "directory_group", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateDirectoryGroupInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.DirectoryGroup.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "directory_group", Operation: refOpQuery}

			entities, err := client.DirectoryGroup.Query().
				Where(directorygroup.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "directory_group", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.DirectoryGroup.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "directory_group.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "directory_group", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateDirectoryGroupInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.IntegrationID == "" {
						input.IntegrationID = integration.ID
					}
					if input.PlatformID == nil && integration.PlatformID != "" {
						input.PlatformID = &integration.PlatformID
					}
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaDirectoryMembership = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "DirectoryMembership",
			Snake: "directory_membership",
			Lower: "directorymembership",
		},
		ProjectionType: reflect.TypeFor[DirectoryMembershipProjection](),
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "directory_membership", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateDirectoryMembershipInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.DirectoryMembership.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "directory_membership", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateDirectoryMembershipInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.DirectoryMembership.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "directory_membership", Operation: refOpQuery}

			entities, err := client.DirectoryMembership.Query().
				Where(directorymembership.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "directory_membership", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.DirectoryMembership.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "directory_membership.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "directory_membership", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateDirectoryMembershipInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.IntegrationID == "" {
						input.IntegrationID = integration.ID
					}
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaDirectorySyncRun = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "DirectorySyncRun",
			Snake: "directory_sync_run",
			Lower: "directorysyncrun",
		},
		ProjectionType: reflect.TypeFor[DirectorySyncRunProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "directory_sync_run", Operation: refOpQuery}

			entities, err := client.DirectorySyncRun.Query().
				Where(directorysyncrun.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "directory_sync_run", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.DirectorySyncRun.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaDiscussion = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Discussion",
			Snake: "discussion",
			Lower: "discussion",
		},
		ProjectionType: reflect.TypeFor[DiscussionProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "discussion", Operation: refOpQuery}

			entities, err := client.Discussion.Query().
				Where(discussion.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "discussion", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Discussion.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaDocumentData = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "DocumentData",
			Snake: "document_data",
			Lower: "documentdata",
		},
		ProjectionType: reflect.TypeFor[DocumentDataProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "document_data", Operation: refOpQuery}

			entities, err := client.DocumentData.Query().
				Where(documentdata.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "document_data", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.DocumentData.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaEmailTemplate = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "EmailTemplate",
			Snake: "email_template",
			Lower: "emailtemplate",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "email_template", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.EmailTemplate.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaEmailVerificationToken = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "EmailVerificationToken",
			Snake: "email_verification_token",
			Lower: "emailverificationtoken",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "email_verification_token", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.EmailVerificationToken.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaEntity = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Entity",
			Snake: "entity",
			Lower: "entity",
		},
		ProjectionType: reflect.TypeFor[EntityProjection](),
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "entity", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateEntityInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.Entity.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "entity", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateEntityInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Entity.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "entity", Operation: refOpQuery}

			entities, err := client.Entity.Query().
				Where(entity.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "entity", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Entity.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "entity.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "entity", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateEntityInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaEntityType = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "EntityType",
			Snake: "entity_type",
			Lower: "entitytype",
		},
		ProjectionType: reflect.TypeFor[EntityTypeProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "entity_type", Operation: refOpQuery}

			entities, err := client.EntityType.Query().
				Where(entitytype.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "entity_type", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.EntityType.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaEvent = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Event",
			Snake: "event",
			Lower: "event",
		},
		ProjectionType: reflect.TypeFor[EventProjection](),
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "event", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Event.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaEvidence = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Evidence",
			Snake:            "evidence",
			Lower:            "evidence",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[EvidenceProjection](),
		ConsoleRoute:   &ConsoleRoute{Base: "evidence", IDParam: "id"},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "evidence", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateEvidenceInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Evidence.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "evidence", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Evidence.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Evidence.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "evidence", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaExport = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Export",
			Snake: "export",
			Lower: "export",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "export", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Export.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaFile = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "File",
			Snake: "file",
			Lower: "file",
		},
		ProjectionType: reflect.TypeFor[FileProjection](),
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "file", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.File.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaFileDownloadToken = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "FileDownloadToken",
			Snake: "file_download_token",
			Lower: "filedownloadtoken",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "file_download_token", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.FileDownloadToken.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaFinding = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Finding",
			Snake:            "finding",
			Lower:            "finding",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[FindingProjection](),
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "finding", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateFindingInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.Finding.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "finding", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateFindingInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Finding.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "finding", Operation: refOpQuery}

			entities, err := client.Finding.Query().
				Where(finding.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "finding", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Finding.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Finding.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "finding", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "finding.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "finding", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateFindingInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaFindingControl = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "FindingControl",
			Snake: "finding_control",
			Lower: "findingcontrol",
		},
		ProjectionType: reflect.TypeFor[FindingControlProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "finding_control", Operation: refOpQuery}

			entities, err := client.FindingControl.Query().
				Where(findingcontrol.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "finding_control", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.FindingControl.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaGroup = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Group",
			Snake: "group",
			Lower: "group",
		},
		ProjectionType: reflect.TypeFor[GroupProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "group", Operation: refOpQuery}

			entities, err := client.Group.Query().
				Where(group.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "group", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Group.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaGroupMembership = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "GroupMembership",
			Snake: "group_membership",
			Lower: "groupmembership",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "group_membership", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.GroupMembership.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaGroupSetting = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "GroupSetting",
			Snake: "group_setting",
			Lower: "groupsetting",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "group_setting", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.GroupSetting.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaHush = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Hush",
			Snake: "hush",
			Lower: "hush",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "hush", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Hush.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaIdentityHolder = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "IdentityHolder",
			Snake:            "identity_holder",
			Lower:            "identityholder",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[IdentityHolderProjection](),
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "identity_holder", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateIdentityHolderInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.IdentityHolder.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "identity_holder", Operation: refOpQuery}

			entities, err := client.IdentityHolder.Query().
				Where(identityholder.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "identity_holder", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.IdentityHolder.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.IdentityHolder.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "identity_holder", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaImpersonationEvent = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "ImpersonationEvent",
			Snake: "impersonation_event",
			Lower: "impersonationevent",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "impersonation_event", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.ImpersonationEvent.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaIntegration = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Integration",
			Snake: "integration",
			Lower: "integration",
		},
		ProjectionType: reflect.TypeFor[IntegrationProjection](),
		ConsoleRoute:   &ConsoleRoute{Base: "automation/integrations"},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "integration", Operation: refOpQuery}

			entities, err := client.Integration.Query().
				Where(integration.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "integration", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Integration.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaIntegrationRun = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "IntegrationRun",
			Snake: "integration_run",
			Lower: "integrationrun",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "integration_run", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.IntegrationRun.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaIntegrationWebhook = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "IntegrationWebhook",
			Snake: "integration_webhook",
			Lower: "integrationwebhook",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "integration_webhook", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.IntegrationWebhook.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaInternalPolicy = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "InternalPolicy",
			Snake:            "internal_policy",
			Lower:            "internalpolicy",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[InternalPolicyProjection](),
		ConsoleRoute:   &ConsoleRoute{Base: "policies", Suffix: "view"},
		MentionSpec:    &MentionSpec{Schema: "InternalPolicy", NameField: "name", DetailsField: "details", DetailsJSONField: "details_json", OwnerField: "owner_id"},
		ApprovalSpec:   &ApprovalSpec{Schema: "InternalPolicy", StatusField: "status", ApproverField: "approver_id"},
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "internal_policy", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateInternalPolicyInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.InternalPolicy.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "internal_policy", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateInternalPolicyInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.InternalPolicy.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "internal_policy", Operation: refOpQuery}

			entities, err := client.InternalPolicy.Query().
				Where(internalpolicy.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "internal_policy", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.InternalPolicy.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.InternalPolicy.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "internal_policy", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "internal_policy.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "internal_policy", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateInternalPolicyInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaInvite = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Invite",
			Snake: "invite",
			Lower: "invite",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "invite", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Invite.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaMappableDomain = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "MappableDomain",
			Snake: "mappable_domain",
			Lower: "mappabledomain",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "mappable_domain", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.MappableDomain.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaMappedControl = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "MappedControl",
			Snake: "mapped_control",
			Lower: "mappedcontrol",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "mapped_control", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.MappedControl.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaNarrative = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Narrative",
			Snake: "narrative",
			Lower: "narrative",
		},
		ProjectionType: reflect.TypeFor[NarrativeProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "narrative", Operation: refOpQuery}

			entities, err := client.Narrative.Query().
				Where(narrative.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "narrative", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Narrative.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaNote = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Note",
			Snake: "note",
			Lower: "note",
		},
		ProjectionType: reflect.TypeFor[NoteProjection](),
		MentionSpec:    &MentionSpec{Schema: "Note", NameField: "title", DetailsField: "text", DetailsJSONField: "text_json", OwnerField: "owner_id"},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "note", Operation: refOpQuery}

			entities, err := client.Note.Query().
				Where(note.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "note", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Note.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaNotification = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Notification",
			Snake: "notification",
			Lower: "notification",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "notification", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Notification.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaNotificationPreference = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "NotificationPreference",
			Snake: "notification_preference",
			Lower: "notificationpreference",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "notification_preference", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.NotificationPreference.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaNotificationTemplate = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "NotificationTemplate",
			Snake: "notification_template",
			Lower: "notificationtemplate",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "notification_template", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.NotificationTemplate.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaOnboarding = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Onboarding",
			Snake: "onboarding",
			Lower: "onboarding",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "onboarding", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Onboarding.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaOrgMembership = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "OrgMembership",
			Snake: "org_membership",
			Lower: "orgmembership",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "org_membership", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.OrgMembership.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaOrgModule = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "OrgModule",
			Snake: "org_module",
			Lower: "orgmodule",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "org_module", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.OrgModule.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaOrgPrice = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "OrgPrice",
			Snake: "org_price",
			Lower: "orgprice",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "org_price", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.OrgPrice.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaOrgProduct = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "OrgProduct",
			Snake: "org_product",
			Lower: "orgproduct",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "org_product", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.OrgProduct.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaOrgSubscription = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "OrgSubscription",
			Snake: "org_subscription",
			Lower: "orgsubscription",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "org_subscription", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.OrgSubscription.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaOrganization = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Organization",
			Snake: "organization",
			Lower: "organization",
		},
		ProjectionType: reflect.TypeFor[OrganizationProjection](),
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "organization", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Organization.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaOrganizationSetting = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "OrganizationSetting",
			Snake: "organization_setting",
			Lower: "organizationsetting",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "organization_setting", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.OrganizationSetting.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaPasswordResetToken = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "PasswordResetToken",
			Snake: "password_reset_token",
			Lower: "passwordresettoken",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "password_reset_token", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.PasswordResetToken.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaPersonalAccessToken = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "PersonalAccessToken",
			Snake: "personal_access_token",
			Lower: "personalaccesstoken",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "personal_access_token", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.PersonalAccessToken.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaPlatform = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Platform",
			Snake:            "platform",
			Lower:            "platform",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[PlatformProjection](),
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "platform", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdatePlatformInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Platform.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "platform", Operation: refOpQuery}

			entities, err := client.Platform.Query().
				Where(platform.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "platform", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Platform.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Platform.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "platform", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaProcedure = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Procedure",
			Snake:            "procedure",
			Lower:            "procedure",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[ProcedureProjection](),
		ConsoleRoute:   &ConsoleRoute{Base: "procedures", Suffix: "view"},
		MentionSpec:    &MentionSpec{Schema: "Procedure", NameField: "name", DetailsField: "details", DetailsJSONField: "details_json", OwnerField: "owner_id"},
		ApprovalSpec:   &ApprovalSpec{Schema: "Procedure", StatusField: "status", ApproverField: "approver_id"},
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "procedure", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateProcedureInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.Procedure.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "procedure", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateProcedureInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Procedure.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "procedure", Operation: refOpQuery}

			entities, err := client.Procedure.Query().
				Where(procedure.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "procedure", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Procedure.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Procedure.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "procedure", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "procedure.ingest.requested"),
			prepare: func(ctx context.Context, _ *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "procedure", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateProcedureInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaProgram = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Program",
			Snake: "program",
			Lower: "program",
		},
		ProjectionType: reflect.TypeFor[ProgramProjection](),
		ConsoleRoute:   &ConsoleRoute{Base: "programs"},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "program", Operation: refOpQuery}

			entities, err := client.Program.Query().
				Where(program.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "program", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Program.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaProgramMembership = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "ProgramMembership",
			Snake: "program_membership",
			Lower: "programmembership",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "program_membership", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.ProgramMembership.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaRemediation = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Remediation",
			Snake:            "remediation",
			Lower:            "remediation",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[RemediationProjection](),
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "remediation", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateRemediationInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Remediation.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "remediation", Operation: refOpQuery}

			entities, err := client.Remediation.Query().
				Where(remediation.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "remediation", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Remediation.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Remediation.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "remediation", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaReview = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Review",
			Snake: "review",
			Lower: "review",
		},
		ProjectionType: reflect.TypeFor[ReviewProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "review", Operation: refOpQuery}

			entities, err := client.Review.Query().
				Where(review.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "review", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Review.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaRisk = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Risk",
			Snake:            "risk",
			Lower:            "risk",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[RiskProjection](),
		ConsoleRoute:   &ConsoleRoute{Base: "exposure/risks"},
		MentionSpec:    &MentionSpec{Schema: "Risk", NameField: "name", DetailsField: "details", DetailsJSONField: "details_json", OwnerField: "owner_id"},
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "risk", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateRiskInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.Risk.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "risk", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateRiskInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Risk.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "risk", Operation: refOpQuery}

			entities, err := client.Risk.Query().
				Where(risk.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "risk", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Risk.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Risk.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "risk", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "risk.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "risk", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateRiskInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
					if input.IntegrationID == nil && integration.ID != "" {
						input.IntegrationID = &integration.ID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaSLADefinition = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "SLADefinition",
			Snake: "sla_definition",
			Lower: "sladefinition",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "sla_definition", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.SLADefinition.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaScan = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Scan",
			Snake: "scan",
			Lower: "scan",
		},
		ProjectionType: reflect.TypeFor[ScanProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "scan", Operation: refOpQuery}

			entities, err := client.Scan.Query().
				Where(scan.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "scan", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Scan.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaStandard = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Standard",
			Snake: "standard",
			Lower: "standard",
		},
		ConsoleRoute: &ConsoleRoute{Base: "standards"},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "standard", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Standard.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaSubcontrol = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Subcontrol",
			Snake:            "subcontrol",
			Lower:            "subcontrol",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[SubcontrolProjection](),
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "subcontrol", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateSubcontrolInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Subcontrol.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "subcontrol", Operation: refOpQuery}

			entities, err := client.Subcontrol.Query().
				Where(subcontrol.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "subcontrol", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Subcontrol.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Subcontrol.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "subcontrol", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaSubprocessor = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Subprocessor",
			Snake: "subprocessor",
			Lower: "subprocessor",
		},
		ProjectionType: reflect.TypeFor[SubprocessorProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "subprocessor", Operation: refOpQuery}

			entities, err := client.Subprocessor.Query().
				Where(subprocessor.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "subprocessor", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Subprocessor.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaSubscriber = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Subscriber",
			Snake: "subscriber",
			Lower: "subscriber",
		},
		ProjectionType: reflect.TypeFor[SubscriberProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "subscriber", Operation: refOpQuery}

			entities, err := client.Subscriber.Query().
				Where(subscriber.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "subscriber", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Subscriber.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaSystemDetail = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "SystemDetail",
			Snake: "system_detail",
			Lower: "systemdetail",
		},
		ProjectionType: reflect.TypeFor[SystemDetailProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "system_detail", Operation: refOpQuery}

			entities, err := client.SystemDetail.Query().
				Where(systemdetail.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "system_detail", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.SystemDetail.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTFASetting = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TFASetting",
			Snake: "tfa_setting",
			Lower: "tfasetting",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "tfa_setting", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TFASetting.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTagDefinition = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TagDefinition",
			Snake: "tag_definition",
			Lower: "tagdefinition",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "tag_definition", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TagDefinition.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTask = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Task",
			Snake:            "task",
			Lower:            "task",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[TaskProjection](),
		ConsoleRoute:   &ConsoleRoute{Base: "automation/tasks", IDParam: "id"},
		MentionSpec:    &MentionSpec{Schema: "Task", NameField: "title", DetailsField: "details", DetailsJSONField: "details_json", OwnerField: "owner_id"},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "task", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateTaskInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Task.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "task", Operation: refOpQuery}

			entities, err := client.Task.Query().
				Where(task.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "task", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Task.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Task.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "task", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
	}
	SchemaTemplate = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Template",
			Snake: "template",
			Lower: "template",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "template", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Template.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTrustCenter = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TrustCenter",
			Snake: "trust_center",
			Lower: "trustcenter",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "trust_center", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TrustCenter.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTrustCenterCompliance = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TrustCenterCompliance",
			Snake: "trust_center_compliance",
			Lower: "trustcentercompliance",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "trust_center_compliance", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TrustCenterCompliance.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTrustCenterDoc = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TrustCenterDoc",
			Snake: "trust_center_doc",
			Lower: "trustcenterdoc",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "trust_center_doc", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TrustCenterDoc.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTrustCenterEntity = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TrustCenterEntity",
			Snake: "trust_center_entity",
			Lower: "trustcenterentity",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "trust_center_entity", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TrustCenterEntity.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTrustCenterFAQ = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TrustCenterFAQ",
			Snake: "trust_center_faq",
			Lower: "trustcenterfaq",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "trust_center_faq", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TrustCenterFAQ.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTrustCenterNDARequest = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TrustCenterNDARequest",
			Snake: "trust_center_nda_request",
			Lower: "trustcenterndarequest",
		},
		ConsoleRoute: &ConsoleRoute{Base: "trust-center/NDAs"},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "trust_center_nda_request", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TrustCenterNDARequest.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTrustCenterSetting = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TrustCenterSetting",
			Snake: "trust_center_setting",
			Lower: "trustcentersetting",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "trust_center_setting", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TrustCenterSetting.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTrustCenterSubprocessor = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TrustCenterSubprocessor",
			Snake: "trust_center_subprocessor",
			Lower: "trustcentersubprocessor",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "trust_center_subprocessor", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TrustCenterSubprocessor.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaTrustCenterWatermarkConfig = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "TrustCenterWatermarkConfig",
			Snake: "trust_center_watermark_config",
			Lower: "trustcenterwatermarkconfig",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "trust_center_watermark_config", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.TrustCenterWatermarkConfig.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaUser = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "User",
			Snake: "user",
			Lower: "user",
		},
		ProjectionType: reflect.TypeFor[UserProjection](),
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "user", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.User.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaUserSetting = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "UserSetting",
			Snake: "user_setting",
			Lower: "usersetting",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "user_setting", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.UserSetting.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaVendorRiskScore = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "VendorRiskScore",
			Snake: "vendor_risk_score",
			Lower: "vendorriskscore",
		},
		ProjectionType: reflect.TypeFor[VendorRiskScoreProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "vendor_risk_score", Operation: refOpQuery}

			entities, err := client.VendorRiskScore.Query().
				Where(vendorriskscore.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "vendor_risk_score", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.VendorRiskScore.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaVendorScoringConfig = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "VendorScoringConfig",
			Snake: "vendor_scoring_config",
			Lower: "vendorscoringconfig",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "vendor_scoring_config", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.VendorScoringConfig.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaVulnerability = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Vulnerability",
			Snake:            "vulnerability",
			Lower:            "vulnerability",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[VulnerabilityProjection](),
		Create: func(ctx context.Context, client *generated.Client, input json.RawMessage) (string, error) {
			ref := SchemaRef{Schema: "vulnerability", Operation: refOpCreate}

			decoded, err := jsonx.Decode[generated.CreateVulnerabilityInput](input)
			if err != nil {
				return "", logError(ctx, ref, ErrDecodeFailed, err)
			}

			entity, err := client.Vulnerability.Create().SetInput(decoded).Save(ctx)
			if err != nil {
				return "", logPersistError(ctx, ref, ErrCreateFailed, err)
			}

			return entity.ID, nil
		},
		Update: func(ctx context.Context, client *generated.Client, entityID string, input json.RawMessage) error {
			ref := SchemaRef{Schema: "vulnerability", Operation: refOpUpdate, EntityID: entityID}

			decoded, err := jsonx.Decode[generated.UpdateVulnerabilityInput](applyClears(input))
			if err != nil {
				return logError(ctx, ref, ErrDecodeFailed, err)
			}

			if err := client.Vulnerability.UpdateOneID(entityID).SetInput(decoded).Exec(ctx); err != nil {
				return logPersistError(ctx, ref, ErrUpdateFailed, err)
			}

			return nil
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "vulnerability", Operation: refOpQuery}

			entities, err := client.Vulnerability.Query().
				Where(vulnerability.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "vulnerability", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Vulnerability.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
		LoadObject: func(ctx context.Context, client *generated.Client, entityID string) (any, error) {
			entity, err := client.Vulnerability.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, SchemaRef{Schema: "vulnerability", Operation: refOpLoad, EntityID: entityID}, ErrLoadFailed, err)
			}

			return entity, nil
		},
		Ingest: &IngestCapability{
			Topic: gala.NamespacedTopic[IngestRequest](IngestTopics, "vulnerability.ingest.requested"),
			prepare: func(ctx context.Context, integration *generated.Integration, payload json.RawMessage) (json.RawMessage, error) {
				ref := SchemaRef{Schema: "vulnerability", Operation: refOpCreate}

				input, err := jsonx.Decode[generated.CreateVulnerabilityInput](payload)
				if err != nil {
					return nil, logError(ctx, ref, ErrDecodeFailed, err)
				}

				if integration != nil {
					if input.OwnerID == nil && integration.OwnerID != "" {
						input.OwnerID = &integration.OwnerID
					}
				}

				prepared, err := json.Marshal(input)
				if err != nil {
					return nil, logError(ctx, ref, ErrMarshalFailed, err)
				}

				return prepared, nil
			},
		},
	}
	SchemaWebauthn = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Webauthn",
			Snake: "webauthn",
			Lower: "webauthn",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "webauthn", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.Webauthn.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaWorkflowAssignment = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "WorkflowAssignment",
			Snake: "workflow_assignment",
			Lower: "workflowassignment",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "workflow_assignment", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.WorkflowAssignment.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaWorkflowAssignmentTarget = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "WorkflowAssignmentTarget",
			Snake: "workflow_assignment_target",
			Lower: "workflowassignmenttarget",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "workflow_assignment_target", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.WorkflowAssignmentTarget.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaWorkflowDefinition = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "WorkflowDefinition",
			Snake: "workflow_definition",
			Lower: "workflowdefinition",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "workflow_definition", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.WorkflowDefinition.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaWorkflowEvent = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "WorkflowEvent",
			Snake: "workflow_event",
			Lower: "workflowevent",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "workflow_event", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.WorkflowEvent.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaWorkflowInstance = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "WorkflowInstance",
			Snake: "workflow_instance",
			Lower: "workflowinstance",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "workflow_instance", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.WorkflowInstance.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaWorkflowObjectRef = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "WorkflowObjectRef",
			Snake: "workflow_object_ref",
			Lower: "workflowobjectref",
		},
		ProjectionType: reflect.TypeFor[WorkflowObjectRefProjection](),
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "workflow_object_ref", Operation: refOpQuery}

			entities, err := client.WorkflowObjectRef.Query().
				Where(workflowobjectref.OwnerID(orgID)).
				All(ctx)
			if err != nil {
				return nil, logError(ctx, ref, ErrQueryFailed, err)
			}

			results := make([]json.RawMessage, 0, len(entities))
			for _, e := range entities {
				data, err := json.Marshal(e)
				if err != nil {
					logError(ctx, ref, ErrMarshalFailed, err)
					continue
				}

				results = append(results, data)
			}

			return results, nil
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "workflow_object_ref", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.WorkflowObjectRef.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
	SchemaWorkflowProposal = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "WorkflowProposal",
			Snake: "workflow_proposal",
			Lower: "workflowproposal",
		},
		Load: func(ctx context.Context, client *generated.Client, entityID string) (json.RawMessage, error) {
			ref := SchemaRef{Schema: "workflow_proposal", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.WorkflowProposal.Get(ctx, entityID)
			if err != nil {
				return nil, logError(ctx, ref, ErrLoadFailed, err)
			}

			data, err := json.Marshal(entity)
			if err != nil {
				return nil, logError(ctx, ref, ErrMarshalFailed, err)
			}

			return data, nil
		},
	}
)

var AllMutationOps = []string{OpCreate, OpUpdate, OpUpdateOne, OpDelete, OpDeleteOne, OpSoftDelete}

var IngestTopics = gala.IntegrationIngest.At("entityops")

var RegularMutationOps = []string{OpCreate, OpUpdate, OpUpdateOne, OpDelete, OpDeleteOne}