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 registered incorrectly at startup
	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")
	// ErrUpsertStaleRun indicates an ingest update was superseded by a newer or equal integration run
	ErrUpsertStaleRun = errors.New("entityops: upsert stale run")
	// ErrLookupAlternativeInvalid indicates a lookup names an alternative index the schema does not declare
	ErrLookupAlternativeInvalid = errors.New("entityops: lookup alternative invalid")
)

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"},
		IntegrationM2MEdge:    "integrations",
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_file_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)
			}

			builder := client.ActionPlan.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.ActionPlan.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	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)
			}

			builder := client.Assessment.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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](),
		IntegrationFKField:    "integration_id",
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"source_identifier"}},
		},
		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)
			}

			builder := client.Asset.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.Asset.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	SchemaCampaign = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "Campaign",
			Snake:            "campaign",
			Lower:            "campaign",
			WorkflowEligible: true,
		},
		ProjectionType:     reflect.TypeFor[CampaignProjection](),
		IntegrationFKField: "integration_id",
		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)
			}

			builder := client.Campaign.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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)
			}

			builder := client.CampaignTarget.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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](),
		IntegrationFKField:    "integration_id",
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"parent_external_id"}},
		},
		InstanceScoped: true,
		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)
			}

			builder := client.CheckResult.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.CheckResult.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	SchemaContact = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "Contact",
			Snake: "contact",
			Lower: "contact",
		},
		ProjectionType:        reflect.TypeFor[ContactProjection](),
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_id"}},
			{Fields: []string{"email"}},
		},
		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)
			}

			builder := client.Contact.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.Contact.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	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)
			}

			builder := client.Control.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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](),
		IntegrationFKField:    "integration_id",
		IntegrationRunM2MEdge: "integration_runs",
		RemovedAtField:        "removed_at",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_id"}},
		},
		InstanceScoped: true,
		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)
			}

			builder := client.DirectoryAccount.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.DirectoryAccount.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	SchemaDirectoryGroup = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "DirectoryGroup",
			Snake: "directory_group",
			Lower: "directorygroup",
		},
		ProjectionType:        reflect.TypeFor[DirectoryGroupProjection](),
		IntegrationFKField:    "integration_id",
		IntegrationRunM2MEdge: "integration_runs",
		RemovedAtField:        "removed_at",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_id"}},
		},
		InstanceScoped: true,
		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)
			}

			builder := client.DirectoryGroup.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.DirectoryGroup.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	SchemaDirectoryMembership = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "DirectoryMembership",
			Snake: "directory_membership",
			Lower: "directorymembership",
		},
		ProjectionType:        reflect.TypeFor[DirectoryMembershipProjection](),
		IntegrationFKField:    "integration_id",
		IntegrationRunM2MEdge: "integration_runs",
		RemovedAtField:        "removed_at",
		RemovedAtEpisodic:     true,
		Lookup: []LookupAlternative{
			{Fields: []string{"directory_account_id", "directory_group_id"}},
		},
		InstanceScoped: true,
		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)
			}

			builder := client.DirectoryMembership.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.DirectoryMembership.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	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",
		},
		IntegrationFKField: "integration_id",
		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](),
		IntegrationM2MEdge:    "integrations",
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_id"}},
		},
		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)
			}

			builder := client.Entity.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.Entity.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	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](),
		IntegrationM2MEdge: "integrations",
		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)
			}

			builder := client.Evidence.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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](),
		IntegrationM2MEdge: "integrations",
		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](),
		IntegrationM2MEdge:    "integrations",
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_id"}},
		},
		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)
			}

			builder := client.Finding.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.Finding.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	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](),
		IntegrationM2MEdge: "integrations",
		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",
		},
		IntegrationM2MEdge: "integrations",
		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)
			}

			builder := client.IdentityHolder.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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"},
		IntegrationRunM2MEdge: "integration_runs",
		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",
		},
		ProjectionType:     reflect.TypeFor[IntegrationRunProjection](),
		IntegrationFKField: "integration_id",
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "integration_run", Operation: refOpQuery}

			entities, err := client.IntegrationRun.Query().
				Where(integrationrun.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_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",
		},
		IntegrationFKField: "integration_id",
		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"},
		IntegrationM2MEdge:    "integrations",
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_file_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)
			}

			builder := client.InternalPolicy.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.InternalPolicy.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	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",
		},
		IntegrationFKField: "integration_id",
		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](),
		IntegrationM2MEdge:    "integrations",
		IntegrationRunM2MEdge: "integration_runs",
		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](),
		IntegrationM2MEdge: "integrations",
		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)
			}

			builder := client.Platform.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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"},
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_file_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)
			}

			builder := client.Procedure.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.Procedure.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	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](),
		IntegrationM2MEdge: "integrations",
		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)
			}

			builder := client.Remediation.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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](),
		IntegrationM2MEdge: "integrations",
		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"},
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_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)
			}

			builder := client.Risk.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.Risk.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	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)
			}

			builder := client.Subcontrol.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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)
			}

			builder := client.Task.UpdateOneID(entityID).SetInput(decoded)

			if err := builder.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](),
		IntegrationM2MEdge:    "integrations",
		IntegrationRunM2MEdge: "integration_runs",
		Lookup: []LookupAlternative{
			{Fields: []string{"external_id"}},
		},
		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)
			}

			builder := client.Vulnerability.Create().SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return "", logError(ctx, ref, ErrCreateFailed, err)
			}

			entity, err := builder.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)
			}

			builder := client.Vulnerability.UpdateOneID(entityID).SetInput(decoded)

			if err := applyStampedFields(builder.Mutation(), input, FieldIntegrationRunID, FieldManagedBy, FieldSourceDefinitionID, FieldSourceDefinitionVersion, FieldSourceInstanceID); err != nil {
				return logError(ctx, ref, ErrUpdateFailed, err)
			}

			if err := builder.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"),
		},
	}
	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",
		},
		IntegrationFKField: "integration_id",
		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 ActionPlanFields = struct {
	// ActionPlanKindID is the action_plan_kind_id field
	ActionPlanKindID FieldDescriptor
	// ActionPlanKindName is the action_plan_kind_name field
	ActionPlanKindName FieldDescriptor
	// ApprovalRequired is the approval_required field
	ApprovalRequired FieldDescriptor
	// ApproverID is the approver_id field
	ApproverID FieldDescriptor
	// Blocked is the blocked field
	Blocked FieldDescriptor
	// BlockerReason is the blocker_reason field
	BlockerReason FieldDescriptor
	// CompletedAt is the completed_at field
	CompletedAt FieldDescriptor
	// ControlSuggestions is the control_suggestions field
	ControlSuggestions FieldDescriptor
	// DelegateID is the delegate_id field
	DelegateID FieldDescriptor
	// Description is the description field
	Description FieldDescriptor
	// Details is the details field
	Details FieldDescriptor
	// DetailsJSON is the details_json field
	DetailsJSON FieldDescriptor
	// DismissedControlSuggestions is the dismissed_control_suggestions field
	DismissedControlSuggestions FieldDescriptor
	// DismissedImprovementSuggestions is the dismissed_improvement_suggestions field
	DismissedImprovementSuggestions FieldDescriptor
	// DismissedTagSuggestions is the dismissed_tag_suggestions field
	DismissedTagSuggestions FieldDescriptor
	// DueDate is the due_date field
	DueDate FieldDescriptor
	// ExternalContents is the external_contents field
	ExternalContents FieldDescriptor
	// ExternalFileID is the external_file_id field
	ExternalFileID FieldDescriptor
	// ImprovementSuggestions is the improvement_suggestions field
	ImprovementSuggestions FieldDescriptor
	// InternalNotes is the internal_notes field
	InternalNotes FieldDescriptor
	// ManagementMode is the management_mode field
	ManagementMode FieldDescriptor
	// Metadata is the metadata field
	Metadata FieldDescriptor
	// Name is the name field
	Name FieldDescriptor
	// Priority is the priority field
	Priority FieldDescriptor
	// RawPayload is the raw_payload field
	RawPayload FieldDescriptor
	// RequiresApproval is the requires_approval field
	RequiresApproval FieldDescriptor
	// ReviewDue is the review_due field
	ReviewDue FieldDescriptor
	// ReviewFrequency is the review_frequency field
	ReviewFrequency FieldDescriptor
	// Revision is the revision field
	Revision FieldDescriptor
	// Source is the source field
	Source FieldDescriptor
	// Status is the status field
	Status FieldDescriptor
	// SystemInternalID is the system_internal_id field
	SystemInternalID FieldDescriptor
	// TagSuggestions is the tag_suggestions field
	TagSuggestions FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
	// Title is the title field
	Title FieldDescriptor
	// URL is the url field
	URL FieldDescriptor
}{
	ActionPlanKindID:                FieldDescriptor{Name: "action_plan_kind_id", InputKey: "action_plan_kind_id"},
	ActionPlanKindName:              FieldDescriptor{Name: "action_plan_kind_name", InputKey: "action_plan_kind_name"},
	ApprovalRequired:                FieldDescriptor{Name: "approval_required", InputKey: "approval_required"},
	ApproverID:                      FieldDescriptor{Name: "approver_id", InputKey: "approver_id"},
	Blocked:                         FieldDescriptor{Name: "blocked", InputKey: "blocked"},
	BlockerReason:                   FieldDescriptor{Name: "blocker_reason", InputKey: "blocker_reason"},
	CompletedAt:                     FieldDescriptor{Name: "completed_at", InputKey: "completed_at"},
	ControlSuggestions:              FieldDescriptor{Name: "control_suggestions", InputKey: "control_suggestions"},
	DelegateID:                      FieldDescriptor{Name: "delegate_id", InputKey: "delegate_id"},
	Description:                     FieldDescriptor{Name: "description", InputKey: "description"},
	Details:                         FieldDescriptor{Name: "details", InputKey: "details"},
	DetailsJSON:                     FieldDescriptor{Name: "details_json", InputKey: "details_json"},
	DismissedControlSuggestions:     FieldDescriptor{Name: "dismissed_control_suggestions", InputKey: "dismissed_control_suggestions"},
	DismissedImprovementSuggestions: FieldDescriptor{Name: "dismissed_improvement_suggestions", InputKey: "dismissed_improvement_suggestions"},
	DismissedTagSuggestions:         FieldDescriptor{Name: "dismissed_tag_suggestions", InputKey: "dismissed_tag_suggestions"},
	DueDate:                         FieldDescriptor{Name: "due_date", InputKey: "due_date"},
	ExternalContents:                FieldDescriptor{Name: "external_contents", InputKey: "external_contents"},
	ExternalFileID:                  FieldDescriptor{Name: "external_file_id", InputKey: "external_file_id"},
	ImprovementSuggestions:          FieldDescriptor{Name: "improvement_suggestions", InputKey: "improvement_suggestions"},
	InternalNotes:                   FieldDescriptor{Name: "internal_notes", InputKey: "internal_notes"},
	ManagementMode:                  FieldDescriptor{Name: "management_mode", InputKey: "management_mode"},
	Metadata:                        FieldDescriptor{Name: "metadata", InputKey: "metadata"},
	Name:                            FieldDescriptor{Name: "name", InputKey: "name"},
	Priority:                        FieldDescriptor{Name: "priority", InputKey: "priority"},
	RawPayload:                      FieldDescriptor{Name: "raw_payload", InputKey: "raw_payload"},
	RequiresApproval:                FieldDescriptor{Name: "requires_approval", InputKey: "requires_approval"},
	ReviewDue:                       FieldDescriptor{Name: "review_due", InputKey: "review_due"},
	ReviewFrequency:                 FieldDescriptor{Name: "review_frequency", InputKey: "review_frequency"},
	Revision:                        FieldDescriptor{Name: "revision", InputKey: "revision"},
	Source:                          FieldDescriptor{Name: "source", InputKey: "source"},
	Status:                          FieldDescriptor{Name: "status", InputKey: "status"},
	SystemInternalID:                FieldDescriptor{Name: "system_internal_id", InputKey: "system_internal_id"},
	TagSuggestions:                  FieldDescriptor{Name: "tag_suggestions", InputKey: "tag_suggestions"},
	Tags:                            FieldDescriptor{Name: "tags", InputKey: "tags"},
	Title:                           FieldDescriptor{Name: "title", InputKey: "title"},
	URL:                             FieldDescriptor{Name: "url", InputKey: "url"},
}

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

var AssetFields = struct {
	// AccessModelID is the access_model_id field
	AccessModelID FieldDescriptor
	// AccessModelName is the access_model_name field
	AccessModelName FieldDescriptor
	// AssetDataClassificationID is the asset_data_classification_id field
	AssetDataClassificationID FieldDescriptor
	// AssetDataClassificationName is the asset_data_classification_name field
	AssetDataClassificationName FieldDescriptor
	// AssetSubtypeID is the asset_subtype_id field
	AssetSubtypeID FieldDescriptor
	// AssetSubtypeName is the asset_subtype_name field
	AssetSubtypeName FieldDescriptor
	// AssetType is the asset_type field
	AssetType FieldDescriptor
	// Categories is the categories field
	Categories FieldDescriptor
	// ContainsPii is the contains_pii field
	ContainsPii FieldDescriptor
	// CostCenter is the cost_center field
	CostCenter FieldDescriptor
	// CriticalityID is the criticality_id field
	CriticalityID FieldDescriptor
	// CriticalityName is the criticality_name field
	CriticalityName FieldDescriptor
	// Description is the description field
	Description FieldDescriptor
	// DisplayName is the display_name field
	DisplayName FieldDescriptor
	// EncryptionStatusID is the encryption_status_id field
	EncryptionStatusID FieldDescriptor
	// EncryptionStatusName is the encryption_status_name field
	EncryptionStatusName FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// EstimatedMonthlyCost is the estimated_monthly_cost field
	EstimatedMonthlyCost FieldDescriptor
	// Identifier is the identifier field
	Identifier FieldDescriptor
	// InternalNotes is the internal_notes field
	InternalNotes FieldDescriptor
	// InternalOwner is the internal_owner field
	InternalOwner FieldDescriptor
	// InternalOwnerGroupID is the internal_owner_group_id field
	InternalOwnerGroupID FieldDescriptor
	// InternalOwnerIdentityHolderID is the internal_owner_identity_holder_id field
	InternalOwnerIdentityHolderID FieldDescriptor
	// InternalOwnerUserID is the internal_owner_user_id field
	InternalOwnerUserID FieldDescriptor
	// Name is the name field
	Name FieldDescriptor
	// ObservedAt is the observed_at field
	ObservedAt FieldDescriptor
	// PhysicalLocation is the physical_location field
	PhysicalLocation FieldDescriptor
	// PurchaseDate is the purchase_date field
	PurchaseDate FieldDescriptor
	// Region is the region field
	Region FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// SecurityTierID is the security_tier_id field
	SecurityTierID FieldDescriptor
	// SecurityTierName is the security_tier_name field
	SecurityTierName FieldDescriptor
	// SourceIdentifier is the source_identifier field
	SourceIdentifier FieldDescriptor
	// SourceType is the source_type field
	SourceType FieldDescriptor
	// SystemInternalID is the system_internal_id field
	SystemInternalID FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
	// Website is the website field
	Website FieldDescriptor
}{
	AccessModelID:                 FieldDescriptor{Name: "access_model_id", InputKey: "access_model_id"},
	AccessModelName:               FieldDescriptor{Name: "access_model_name", InputKey: "access_model_name"},
	AssetDataClassificationID:     FieldDescriptor{Name: "asset_data_classification_id", InputKey: "asset_data_classification_id"},
	AssetDataClassificationName:   FieldDescriptor{Name: "asset_data_classification_name", InputKey: "asset_data_classification_name"},
	AssetSubtypeID:                FieldDescriptor{Name: "asset_subtype_id", InputKey: "asset_subtype_id"},
	AssetSubtypeName:              FieldDescriptor{Name: "asset_subtype_name", InputKey: "asset_subtype_name"},
	AssetType:                     FieldDescriptor{Name: "asset_type", InputKey: "asset_type"},
	Categories:                    FieldDescriptor{Name: "categories", InputKey: "categories"},
	ContainsPii:                   FieldDescriptor{Name: "contains_pii", InputKey: "contains_pii"},
	CostCenter:                    FieldDescriptor{Name: "cost_center", InputKey: "cost_center"},
	CriticalityID:                 FieldDescriptor{Name: "criticality_id", InputKey: "criticality_id"},
	CriticalityName:               FieldDescriptor{Name: "criticality_name", InputKey: "criticality_name"},
	Description:                   FieldDescriptor{Name: "description", InputKey: "description"},
	DisplayName:                   FieldDescriptor{Name: "display_name", InputKey: "display_name"},
	EncryptionStatusID:            FieldDescriptor{Name: "encryption_status_id", InputKey: "encryption_status_id"},
	EncryptionStatusName:          FieldDescriptor{Name: "encryption_status_name", InputKey: "encryption_status_name"},
	EnvironmentID:                 FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:               FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	EstimatedMonthlyCost:          FieldDescriptor{Name: "estimated_monthly_cost", InputKey: "estimated_monthly_cost"},
	Identifier:                    FieldDescriptor{Name: "identifier", InputKey: "identifier"},
	InternalNotes:                 FieldDescriptor{Name: "internal_notes", InputKey: "internal_notes"},
	InternalOwner:                 FieldDescriptor{Name: "internal_owner", InputKey: "internal_owner"},
	InternalOwnerGroupID:          FieldDescriptor{Name: "internal_owner_group_id", InputKey: "internal_owner_group_id"},
	InternalOwnerIdentityHolderID: FieldDescriptor{Name: "internal_owner_identity_holder_id", InputKey: "internal_owner_identity_holder_id"},
	InternalOwnerUserID:           FieldDescriptor{Name: "internal_owner_user_id", InputKey: "internal_owner_user_id"},
	Name:                          FieldDescriptor{Name: "name", InputKey: "name"},
	ObservedAt:                    FieldDescriptor{Name: "observed_at", InputKey: "observed_at"},
	PhysicalLocation:              FieldDescriptor{Name: "physical_location", InputKey: "physical_location"},
	PurchaseDate:                  FieldDescriptor{Name: "purchase_date", InputKey: "purchase_date"},
	Region:                        FieldDescriptor{Name: "region", InputKey: "region"},
	ScopeID:                       FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:                     FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	SecurityTierID:                FieldDescriptor{Name: "security_tier_id", InputKey: "security_tier_id"},
	SecurityTierName:              FieldDescriptor{Name: "security_tier_name", InputKey: "security_tier_name"},
	SourceIdentifier:              FieldDescriptor{Name: "source_identifier", InputKey: "source_identifier"},
	SourceType:                    FieldDescriptor{Name: "source_type", InputKey: "source_type"},
	SystemInternalID:              FieldDescriptor{Name: "system_internal_id", InputKey: "system_internal_id"},
	Tags:                          FieldDescriptor{Name: "tags", InputKey: "tags"},
	Website:                       FieldDescriptor{Name: "website", InputKey: "website"},
}

var CheckResultFields = struct {
	// Details is the details field
	Details FieldDescriptor
	// ExternalURI is the external_uri field
	ExternalURI FieldDescriptor
	// LastObservedAt is the last_observed_at field
	LastObservedAt FieldDescriptor
	// ParentExternalID is the parent_external_id field
	ParentExternalID FieldDescriptor
	// Source is the source field
	Source FieldDescriptor
	// Status is the status field
	Status FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
}{
	Details:          FieldDescriptor{Name: "details", InputKey: "details"},
	ExternalURI:      FieldDescriptor{Name: "external_uri", InputKey: "external_uri"},
	LastObservedAt:   FieldDescriptor{Name: "last_observed_at", InputKey: "last_observed_at"},
	ParentExternalID: FieldDescriptor{Name: "parent_external_id", InputKey: "parent_external_id"},
	Source:           FieldDescriptor{Name: "source", InputKey: "source"},
	Status:           FieldDescriptor{Name: "status", InputKey: "status"},
	Tags:             FieldDescriptor{Name: "tags", InputKey: "tags"},
}

var ContactFields = struct {
	// Address is the address field
	Address FieldDescriptor
	// Company is the company field
	Company FieldDescriptor
	// Email is the email field
	Email FieldDescriptor
	// ExternalID is the external_id field
	ExternalID FieldDescriptor
	// FullName is the full_name field
	FullName FieldDescriptor
	// ObservedAt is the observed_at field
	ObservedAt FieldDescriptor
	// PhoneNumber is the phone_number field
	PhoneNumber FieldDescriptor
	// Status is the status field
	Status FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
	// Title is the title field
	Title FieldDescriptor
}{
	Address:     FieldDescriptor{Name: "address", InputKey: "address"},
	Company:     FieldDescriptor{Name: "company", InputKey: "company"},
	Email:       FieldDescriptor{Name: "email", InputKey: "email"},
	ExternalID:  FieldDescriptor{Name: "external_id", InputKey: "external_id"},
	FullName:    FieldDescriptor{Name: "full_name", InputKey: "full_name"},
	ObservedAt:  FieldDescriptor{Name: "observed_at", InputKey: "observed_at"},
	PhoneNumber: FieldDescriptor{Name: "phone_number", InputKey: "phone_number"},
	Status:      FieldDescriptor{Name: "status", InputKey: "status"},
	Tags:        FieldDescriptor{Name: "tags", InputKey: "tags"},
	Title:       FieldDescriptor{Name: "title", InputKey: "title"},
}

var DirectoryAccountFields = struct {
	// AccountType is the account_type field
	AccountType FieldDescriptor
	// AddedAt is the added_at field
	AddedAt FieldDescriptor
	// AvatarRemoteURL is the avatar_remote_url field
	AvatarRemoteURL FieldDescriptor
	// AvatarUpdatedAt is the avatar_updated_at field
	AvatarUpdatedAt FieldDescriptor
	// CanonicalEmail is the canonical_email field
	CanonicalEmail FieldDescriptor
	// Department is the department field
	Department FieldDescriptor
	// DirectoryName is the directory_name field
	DirectoryName FieldDescriptor
	// DisplayName is the display_name field
	DisplayName FieldDescriptor
	// EmailAliases is the email_aliases field
	EmailAliases FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// ExternalID is the external_id field
	ExternalID FieldDescriptor
	// FamilyName is the family_name field
	FamilyName FieldDescriptor
	// GivenName is the given_name field
	GivenName FieldDescriptor
	// IdentityHolderID is the identity_holder_id field
	IdentityHolderID FieldDescriptor
	// JobTitle is the job_title field
	JobTitle FieldDescriptor
	// LastSeenIP is the last_seen_ip field
	LastSeenIP FieldDescriptor
	// Metadata is the metadata field
	Metadata FieldDescriptor
	// MfaState is the mfa_state field
	MfaState FieldDescriptor
	// ObservedAt is the observed_at field
	ObservedAt FieldDescriptor
	// OrganizationUnit is the organization_unit field
	OrganizationUnit FieldDescriptor
	// PhoneNumber is the phone_number field
	PhoneNumber FieldDescriptor
	// PrimarySource is the primary_source field
	PrimarySource FieldDescriptor
	// Profile is the profile field
	Profile FieldDescriptor
	// RemovedAt is the removed_at field
	RemovedAt FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// SecondaryKey is the secondary_key field
	SecondaryKey FieldDescriptor
	// SourceVersion is the source_version field
	SourceVersion FieldDescriptor
	// Status is the status field
	Status FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
}{
	AccountType:      FieldDescriptor{Name: "account_type", InputKey: "account_type"},
	AddedAt:          FieldDescriptor{Name: "added_at", InputKey: "added_at"},
	AvatarRemoteURL:  FieldDescriptor{Name: "avatar_remote_url", InputKey: "avatar_remote_url"},
	AvatarUpdatedAt:  FieldDescriptor{Name: "avatar_updated_at", InputKey: "avatar_updated_at"},
	CanonicalEmail:   FieldDescriptor{Name: "canonical_email", InputKey: "canonical_email"},
	Department:       FieldDescriptor{Name: "department", InputKey: "department"},
	DirectoryName:    FieldDescriptor{Name: "directory_name", InputKey: "directory_name"},
	DisplayName:      FieldDescriptor{Name: "display_name", InputKey: "display_name"},
	EmailAliases:     FieldDescriptor{Name: "email_aliases", InputKey: "email_aliases"},
	EnvironmentID:    FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:  FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	ExternalID:       FieldDescriptor{Name: "external_id", InputKey: "external_id"},
	FamilyName:       FieldDescriptor{Name: "family_name", InputKey: "family_name"},
	GivenName:        FieldDescriptor{Name: "given_name", InputKey: "given_name"},
	IdentityHolderID: FieldDescriptor{Name: "identity_holder_id", InputKey: "identity_holder_id"},
	JobTitle:         FieldDescriptor{Name: "job_title", InputKey: "job_title"},
	LastSeenIP:       FieldDescriptor{Name: "last_seen_ip", InputKey: "last_seen_ip"},
	Metadata:         FieldDescriptor{Name: "metadata", InputKey: "metadata"},
	MfaState:         FieldDescriptor{Name: "mfa_state", InputKey: "mfa_state"},
	ObservedAt:       FieldDescriptor{Name: "observed_at", InputKey: "observed_at"},
	OrganizationUnit: FieldDescriptor{Name: "organization_unit", InputKey: "organization_unit"},
	PhoneNumber:      FieldDescriptor{Name: "phone_number", InputKey: "phone_number"},
	PrimarySource:    FieldDescriptor{Name: "primary_source", InputKey: "primary_source"},
	Profile:          FieldDescriptor{Name: "profile", InputKey: "profile"},
	RemovedAt:        FieldDescriptor{Name: "removed_at", InputKey: "removed_at"},
	ScopeID:          FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:        FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	SecondaryKey:     FieldDescriptor{Name: "secondary_key", InputKey: "secondary_key"},
	SourceVersion:    FieldDescriptor{Name: "source_version", InputKey: "source_version"},
	Status:           FieldDescriptor{Name: "status", InputKey: "status"},
	Tags:             FieldDescriptor{Name: "tags", InputKey: "tags"},
}

var DirectoryGroupFields = struct {
	// AddedAt is the added_at field
	AddedAt FieldDescriptor
	// Classification is the classification field
	Classification FieldDescriptor
	// DirectoryName is the directory_name field
	DirectoryName FieldDescriptor
	// DisplayName is the display_name field
	DisplayName FieldDescriptor
	// Email is the email field
	Email FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// ExternalID is the external_id field
	ExternalID FieldDescriptor
	// ExternalSharingAllowed is the external_sharing_allowed field
	ExternalSharingAllowed FieldDescriptor
	// MemberCount is the member_count field
	MemberCount FieldDescriptor
	// Metadata is the metadata field
	Metadata FieldDescriptor
	// ObservedAt is the observed_at field
	ObservedAt FieldDescriptor
	// Profile is the profile field
	Profile FieldDescriptor
	// RemovedAt is the removed_at field
	RemovedAt FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// SourceVersion is the source_version field
	SourceVersion FieldDescriptor
	// Status is the status field
	Status FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
}{
	AddedAt:                FieldDescriptor{Name: "added_at", InputKey: "added_at"},
	Classification:         FieldDescriptor{Name: "classification", InputKey: "classification"},
	DirectoryName:          FieldDescriptor{Name: "directory_name", InputKey: "directory_name"},
	DisplayName:            FieldDescriptor{Name: "display_name", InputKey: "display_name"},
	Email:                  FieldDescriptor{Name: "email", InputKey: "email"},
	EnvironmentID:          FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:        FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	ExternalID:             FieldDescriptor{Name: "external_id", InputKey: "external_id"},
	ExternalSharingAllowed: FieldDescriptor{Name: "external_sharing_allowed", InputKey: "external_sharing_allowed"},
	MemberCount:            FieldDescriptor{Name: "member_count", InputKey: "member_count"},
	Metadata:               FieldDescriptor{Name: "metadata", InputKey: "metadata"},
	ObservedAt:             FieldDescriptor{Name: "observed_at", InputKey: "observed_at"},
	Profile:                FieldDescriptor{Name: "profile", InputKey: "profile"},
	RemovedAt:              FieldDescriptor{Name: "removed_at", InputKey: "removed_at"},
	ScopeID:                FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:              FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	SourceVersion:          FieldDescriptor{Name: "source_version", InputKey: "source_version"},
	Status:                 FieldDescriptor{Name: "status", InputKey: "status"},
	Tags:                   FieldDescriptor{Name: "tags", InputKey: "tags"},
}

var DirectoryMembershipFields = struct {
	// AddedAt is the added_at field
	AddedAt FieldDescriptor
	// DirectoryAccountID is the directory_account_id field
	DirectoryAccountID FieldDescriptor
	// DirectoryGroupID is the directory_group_id field
	DirectoryGroupID FieldDescriptor
	// DirectoryName is the directory_name field
	DirectoryName FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// Metadata is the metadata field
	Metadata FieldDescriptor
	// ObservedAt is the observed_at field
	ObservedAt FieldDescriptor
	// PlatformID is the platform_id field
	PlatformID FieldDescriptor
	// RemovedAt is the removed_at field
	RemovedAt FieldDescriptor
	// Role is the role field
	Role FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// Source is the source field
	Source FieldDescriptor
}{
	AddedAt:            FieldDescriptor{Name: "added_at", InputKey: "added_at"},
	DirectoryAccountID: FieldDescriptor{Name: "directory_account_id", InputKey: "directory_account_id"},
	DirectoryGroupID:   FieldDescriptor{Name: "directory_group_id", InputKey: "directory_group_id"},
	DirectoryName:      FieldDescriptor{Name: "directory_name", InputKey: "directory_name"},
	EnvironmentID:      FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:    FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	Metadata:           FieldDescriptor{Name: "metadata", InputKey: "metadata"},
	ObservedAt:         FieldDescriptor{Name: "observed_at", InputKey: "observed_at"},
	PlatformID:         FieldDescriptor{Name: "platform_id", InputKey: "platform_id"},
	RemovedAt:          FieldDescriptor{Name: "removed_at", InputKey: "removed_at"},
	Role:               FieldDescriptor{Name: "role", InputKey: "role"},
	ScopeID:            FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:          FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	Source:             FieldDescriptor{Name: "source", InputKey: "source"},
}

var EntityFields = struct {
	// Aliases is the aliases field
	Aliases FieldDescriptor
	// AnnualSpend is the annual_spend field
	AnnualSpend FieldDescriptor
	// ApprovedForUse is the approved_for_use field
	ApprovedForUse FieldDescriptor
	// AutoRenews is the auto_renews field
	AutoRenews FieldDescriptor
	// BillingModel is the billing_model field
	BillingModel FieldDescriptor
	// ContractEndDate is the contract_end_date field
	ContractEndDate FieldDescriptor
	// ContractRenewalAt is the contract_renewal_at field
	ContractRenewalAt FieldDescriptor
	// ContractStartDate is the contract_start_date field
	ContractStartDate FieldDescriptor
	// Description is the description field
	Description FieldDescriptor
	// DisplayName is the display_name field
	DisplayName FieldDescriptor
	// Domains is the domains field
	Domains FieldDescriptor
	// EntityRelationshipStateID is the entity_relationship_state_id field
	EntityRelationshipStateID FieldDescriptor
	// EntityRelationshipStateName is the entity_relationship_state_name field
	EntityRelationshipStateName FieldDescriptor
	// EntitySecurityQuestionnaireStatusID is the entity_security_questionnaire_status_id field
	EntitySecurityQuestionnaireStatusID FieldDescriptor
	// EntitySecurityQuestionnaireStatusName is the entity_security_questionnaire_status_name field
	EntitySecurityQuestionnaireStatusName FieldDescriptor
	// EntitySourceTypeID is the entity_source_type_id field
	EntitySourceTypeID FieldDescriptor
	// EntitySourceTypeName is the entity_source_type_name field
	EntitySourceTypeName FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// ExternalID is the external_id field
	ExternalID FieldDescriptor
	// HasSoc2 is the has_soc2 field
	HasSoc2 FieldDescriptor
	// InternalNotes is the internal_notes field
	InternalNotes FieldDescriptor
	// InternalOwner is the internal_owner field
	InternalOwner FieldDescriptor
	// InternalOwnerGroupID is the internal_owner_group_id field
	InternalOwnerGroupID FieldDescriptor
	// InternalOwnerIdentityHolderID is the internal_owner_identity_holder_id field
	InternalOwnerIdentityHolderID FieldDescriptor
	// InternalOwnerUserID is the internal_owner_user_id field
	InternalOwnerUserID FieldDescriptor
	// LastReviewedAt is the last_reviewed_at field
	LastReviewedAt FieldDescriptor
	// Links is the links field
	Links FieldDescriptor
	// LogoRemoteURL is the logo_remote_url field
	LogoRemoteURL FieldDescriptor
	// MfaEnforced is the mfa_enforced field
	MfaEnforced FieldDescriptor
	// MfaSupported is the mfa_supported field
	MfaSupported FieldDescriptor
	// Name is the name field
	Name FieldDescriptor
	// NextReviewAt is the next_review_at field
	NextReviewAt FieldDescriptor
	// ObservedAt is the observed_at field
	ObservedAt FieldDescriptor
	// ProvidedServices is the provided_services field
	ProvidedServices FieldDescriptor
	// RenewalRisk is the renewal_risk field
	RenewalRisk FieldDescriptor
	// ReviewFrequency is the review_frequency field
	ReviewFrequency FieldDescriptor
	// ReviewedBy is the reviewed_by field
	ReviewedBy FieldDescriptor
	// ReviewedByGroupID is the reviewed_by_group_id field
	ReviewedByGroupID FieldDescriptor
	// ReviewedByIdentityHolderID is the reviewed_by_identity_holder_id field
	ReviewedByIdentityHolderID FieldDescriptor
	// ReviewedByUserID is the reviewed_by_user_id field
	ReviewedByUserID FieldDescriptor
	// RiskRating is the risk_rating field
	RiskRating FieldDescriptor
	// RiskScore is the risk_score field
	RiskScore FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// Soc2PeriodEnd is the soc2_period_end field
	Soc2PeriodEnd FieldDescriptor
	// SpendCurrency is the spend_currency field
	SpendCurrency FieldDescriptor
	// SSOEnforced is the sso_enforced field
	SSOEnforced FieldDescriptor
	// Status is the status field
	Status FieldDescriptor
	// StatusPageURL is the status_page_url field
	StatusPageURL FieldDescriptor
	// SystemInternalID is the system_internal_id field
	SystemInternalID FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
	// TerminationNoticeDays is the termination_notice_days field
	TerminationNoticeDays FieldDescriptor
	// Tier is the tier field
	Tier FieldDescriptor
	// VendorMetadata is the vendor_metadata field
	VendorMetadata FieldDescriptor
}{
	Aliases:                               FieldDescriptor{Name: "aliases", InputKey: "aliases"},
	AnnualSpend:                           FieldDescriptor{Name: "annual_spend", InputKey: "annual_spend"},
	ApprovedForUse:                        FieldDescriptor{Name: "approved_for_use", InputKey: "approved_for_use"},
	AutoRenews:                            FieldDescriptor{Name: "auto_renews", InputKey: "auto_renews"},
	BillingModel:                          FieldDescriptor{Name: "billing_model", InputKey: "billing_model"},
	ContractEndDate:                       FieldDescriptor{Name: "contract_end_date", InputKey: "contract_end_date"},
	ContractRenewalAt:                     FieldDescriptor{Name: "contract_renewal_at", InputKey: "contract_renewal_at"},
	ContractStartDate:                     FieldDescriptor{Name: "contract_start_date", InputKey: "contract_start_date"},
	Description:                           FieldDescriptor{Name: "description", InputKey: "description"},
	DisplayName:                           FieldDescriptor{Name: "display_name", InputKey: "display_name"},
	Domains:                               FieldDescriptor{Name: "domains", InputKey: "domains"},
	EntityRelationshipStateID:             FieldDescriptor{Name: "entity_relationship_state_id", InputKey: "entity_relationship_state_id"},
	EntityRelationshipStateName:           FieldDescriptor{Name: "entity_relationship_state_name", InputKey: "entity_relationship_state_name"},
	EntitySecurityQuestionnaireStatusID:   FieldDescriptor{Name: "entity_security_questionnaire_status_id", InputKey: "entity_security_questionnaire_status_id"},
	EntitySecurityQuestionnaireStatusName: FieldDescriptor{Name: "entity_security_questionnaire_status_name", InputKey: "entity_security_questionnaire_status_name"},
	EntitySourceTypeID:                    FieldDescriptor{Name: "entity_source_type_id", InputKey: "entity_source_type_id"},
	EntitySourceTypeName:                  FieldDescriptor{Name: "entity_source_type_name", InputKey: "entity_source_type_name"},
	EnvironmentID:                         FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:                       FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	ExternalID:                            FieldDescriptor{Name: "external_id", InputKey: "external_id"},
	HasSoc2:                               FieldDescriptor{Name: "has_soc2", InputKey: "has_soc2"},
	InternalNotes:                         FieldDescriptor{Name: "internal_notes", InputKey: "internal_notes"},
	InternalOwner:                         FieldDescriptor{Name: "internal_owner", InputKey: "internal_owner"},
	InternalOwnerGroupID:                  FieldDescriptor{Name: "internal_owner_group_id", InputKey: "internal_owner_group_id"},
	InternalOwnerIdentityHolderID:         FieldDescriptor{Name: "internal_owner_identity_holder_id", InputKey: "internal_owner_identity_holder_id"},
	InternalOwnerUserID:                   FieldDescriptor{Name: "internal_owner_user_id", InputKey: "internal_owner_user_id"},
	LastReviewedAt:                        FieldDescriptor{Name: "last_reviewed_at", InputKey: "last_reviewed_at"},
	Links:                                 FieldDescriptor{Name: "links", InputKey: "links"},
	LogoRemoteURL:                         FieldDescriptor{Name: "logo_remote_url", InputKey: "logo_remote_url"},
	MfaEnforced:                           FieldDescriptor{Name: "mfa_enforced", InputKey: "mfa_enforced"},
	MfaSupported:                          FieldDescriptor{Name: "mfa_supported", InputKey: "mfa_supported"},
	Name:                                  FieldDescriptor{Name: "name", InputKey: "name"},
	NextReviewAt:                          FieldDescriptor{Name: "next_review_at", InputKey: "next_review_at"},
	ObservedAt:                            FieldDescriptor{Name: "observed_at", InputKey: "observed_at"},
	ProvidedServices:                      FieldDescriptor{Name: "provided_services", InputKey: "provided_services"},
	RenewalRisk:                           FieldDescriptor{Name: "renewal_risk", InputKey: "renewal_risk"},
	ReviewFrequency:                       FieldDescriptor{Name: "review_frequency", InputKey: "review_frequency"},
	ReviewedBy:                            FieldDescriptor{Name: "reviewed_by", InputKey: "reviewed_by"},
	ReviewedByGroupID:                     FieldDescriptor{Name: "reviewed_by_group_id", InputKey: "reviewed_by_group_id"},
	ReviewedByIdentityHolderID:            FieldDescriptor{Name: "reviewed_by_identity_holder_id", InputKey: "reviewed_by_identity_holder_id"},
	ReviewedByUserID:                      FieldDescriptor{Name: "reviewed_by_user_id", InputKey: "reviewed_by_user_id"},
	RiskRating:                            FieldDescriptor{Name: "risk_rating", InputKey: "risk_rating"},
	RiskScore:                             FieldDescriptor{Name: "risk_score", InputKey: "risk_score"},
	ScopeID:                               FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:                             FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	Soc2PeriodEnd:                         FieldDescriptor{Name: "soc2_period_end", InputKey: "soc2_period_end"},
	SpendCurrency:                         FieldDescriptor{Name: "spend_currency", InputKey: "spend_currency"},
	SSOEnforced:                           FieldDescriptor{Name: "sso_enforced", InputKey: "sso_enforced"},
	Status:                                FieldDescriptor{Name: "status", InputKey: "status"},
	StatusPageURL:                         FieldDescriptor{Name: "status_page_url", InputKey: "status_page_url"},
	SystemInternalID:                      FieldDescriptor{Name: "system_internal_id", InputKey: "system_internal_id"},
	Tags:                                  FieldDescriptor{Name: "tags", InputKey: "tags"},
	TerminationNoticeDays:                 FieldDescriptor{Name: "termination_notice_days", InputKey: "termination_notice_days"},
	Tier:                                  FieldDescriptor{Name: "tier", InputKey: "tier"},
	VendorMetadata:                        FieldDescriptor{Name: "vendor_metadata", InputKey: "vendor_metadata"},
}

var FindingFields = struct {
	// AssessmentID is the assessment_id field
	AssessmentID FieldDescriptor
	// AssignedTo is the assigned_to field
	AssignedTo FieldDescriptor
	// AssignedToGroupID is the assigned_to_group_id field
	AssignedToGroupID FieldDescriptor
	// AssignedToIdentityHolderID is the assigned_to_identity_holder_id field
	AssignedToIdentityHolderID FieldDescriptor
	// AssignedToUserID is the assigned_to_user_id field
	AssignedToUserID FieldDescriptor
	// BlocksProduction is the blocks_production field
	BlocksProduction FieldDescriptor
	// Categories is the categories field
	Categories FieldDescriptor
	// Category is the category field
	Category FieldDescriptor
	// Description is the description field
	Description FieldDescriptor
	// DisplayName is the display_name field
	DisplayName FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// EventTime is the event_time field
	EventTime FieldDescriptor
	// Exploitability is the exploitability field
	Exploitability FieldDescriptor
	// ExternalID is the external_id field
	ExternalID FieldDescriptor
	// ExternalOwnerID is the external_owner_id field
	ExternalOwnerID FieldDescriptor
	// ExternalURI is the external_uri field
	ExternalURI FieldDescriptor
	// FindingClass is the finding_class field
	FindingClass FieldDescriptor
	// FindingStatusID is the finding_status_id field
	FindingStatusID FieldDescriptor
	// FindingStatusName is the finding_status_name field
	FindingStatusName FieldDescriptor
	// Impact is the impact field
	Impact FieldDescriptor
	// InternalNotes is the internal_notes field
	InternalNotes FieldDescriptor
	// InternalOwner is the internal_owner field
	InternalOwner FieldDescriptor
	// InternalOwnerGroupID is the internal_owner_group_id field
	InternalOwnerGroupID FieldDescriptor
	// InternalOwnerIdentityHolderID is the internal_owner_identity_holder_id field
	InternalOwnerIdentityHolderID FieldDescriptor
	// InternalOwnerUserID is the internal_owner_user_id field
	InternalOwnerUserID FieldDescriptor
	// Metadata is the metadata field
	Metadata FieldDescriptor
	// NumericSeverity is the numeric_severity field
	NumericSeverity FieldDescriptor
	// Open is the open field
	Open FieldDescriptor
	// Priority is the priority field
	Priority FieldDescriptor
	// Production is the production field
	Production FieldDescriptor
	// Public is the public field
	Public FieldDescriptor
	// RawPayload is the raw_payload field
	RawPayload FieldDescriptor
	// Recommendation is the recommendation field
	Recommendation FieldDescriptor
	// RecommendedActions is the recommended_actions field
	RecommendedActions FieldDescriptor
	// References is the references field
	References FieldDescriptor
	// RemediationSLA is the remediation_sla field
	RemediationSLA FieldDescriptor
	// ReportedAt is the reported_at field
	ReportedAt FieldDescriptor
	// ResourceName is the resource_name field
	ResourceName FieldDescriptor
	// ReviewedBy is the reviewed_by field
	ReviewedBy FieldDescriptor
	// ReviewedByGroupID is the reviewed_by_group_id field
	ReviewedByGroupID FieldDescriptor
	// ReviewedByIdentityHolderID is the reviewed_by_identity_holder_id field
	ReviewedByIdentityHolderID FieldDescriptor
	// ReviewedByUserID is the reviewed_by_user_id field
	ReviewedByUserID FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// Score is the score field
	Score FieldDescriptor
	// Severity is the severity field
	Severity FieldDescriptor
	// Source is the source field
	Source FieldDescriptor
	// SourceUpdatedAt is the source_updated_at field
	SourceUpdatedAt FieldDescriptor
	// State is the state field
	State FieldDescriptor
	// StepsToReproduce is the steps_to_reproduce field
	StepsToReproduce FieldDescriptor
	// SystemInternalID is the system_internal_id field
	SystemInternalID FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
	// TargetDetails is the target_details field
	TargetDetails FieldDescriptor
	// Targets is the targets field
	Targets FieldDescriptor
	// Validated is the validated field
	Validated FieldDescriptor
	// Vector is the vector field
	Vector FieldDescriptor
}{
	AssessmentID:                  FieldDescriptor{Name: "assessment_id", InputKey: "assessment_id"},
	AssignedTo:                    FieldDescriptor{Name: "assigned_to", InputKey: "assigned_to"},
	AssignedToGroupID:             FieldDescriptor{Name: "assigned_to_group_id", InputKey: "assigned_to_group_id"},
	AssignedToIdentityHolderID:    FieldDescriptor{Name: "assigned_to_identity_holder_id", InputKey: "assigned_to_identity_holder_id"},
	AssignedToUserID:              FieldDescriptor{Name: "assigned_to_user_id", InputKey: "assigned_to_user_id"},
	BlocksProduction:              FieldDescriptor{Name: "blocks_production", InputKey: "blocks_production"},
	Categories:                    FieldDescriptor{Name: "categories", InputKey: "categories"},
	Category:                      FieldDescriptor{Name: "category", InputKey: "category"},
	Description:                   FieldDescriptor{Name: "description", InputKey: "description"},
	DisplayName:                   FieldDescriptor{Name: "display_name", InputKey: "display_name"},
	EnvironmentID:                 FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:               FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	EventTime:                     FieldDescriptor{Name: "event_time", InputKey: "event_time"},
	Exploitability:                FieldDescriptor{Name: "exploitability", InputKey: "exploitability"},
	ExternalID:                    FieldDescriptor{Name: "external_id", InputKey: "external_id"},
	ExternalOwnerID:               FieldDescriptor{Name: "external_owner_id", InputKey: "external_owner_id"},
	ExternalURI:                   FieldDescriptor{Name: "external_uri", InputKey: "external_uri"},
	FindingClass:                  FieldDescriptor{Name: "finding_class", InputKey: "finding_class"},
	FindingStatusID:               FieldDescriptor{Name: "finding_status_id", InputKey: "finding_status_id"},
	FindingStatusName:             FieldDescriptor{Name: "finding_status_name", InputKey: "finding_status_name"},
	Impact:                        FieldDescriptor{Name: "impact", InputKey: "impact"},
	InternalNotes:                 FieldDescriptor{Name: "internal_notes", InputKey: "internal_notes"},
	InternalOwner:                 FieldDescriptor{Name: "internal_owner", InputKey: "internal_owner"},
	InternalOwnerGroupID:          FieldDescriptor{Name: "internal_owner_group_id", InputKey: "internal_owner_group_id"},
	InternalOwnerIdentityHolderID: FieldDescriptor{Name: "internal_owner_identity_holder_id", InputKey: "internal_owner_identity_holder_id"},
	InternalOwnerUserID:           FieldDescriptor{Name: "internal_owner_user_id", InputKey: "internal_owner_user_id"},
	Metadata:                      FieldDescriptor{Name: "metadata", InputKey: "metadata"},
	NumericSeverity:               FieldDescriptor{Name: "numeric_severity", InputKey: "numeric_severity"},
	Open:                          FieldDescriptor{Name: "open", InputKey: "open"},
	Priority:                      FieldDescriptor{Name: "priority", InputKey: "priority"},
	Production:                    FieldDescriptor{Name: "production", InputKey: "production"},
	Public:                        FieldDescriptor{Name: "public", InputKey: "public"},
	RawPayload:                    FieldDescriptor{Name: "raw_payload", InputKey: "raw_payload"},
	Recommendation:                FieldDescriptor{Name: "recommendation", InputKey: "recommendation"},
	RecommendedActions:            FieldDescriptor{Name: "recommended_actions", InputKey: "recommended_actions"},
	References:                    FieldDescriptor{Name: "references", InputKey: "references"},
	RemediationSLA:                FieldDescriptor{Name: "remediation_sla", InputKey: "remediation_sla"},
	ReportedAt:                    FieldDescriptor{Name: "reported_at", InputKey: "reported_at"},
	ResourceName:                  FieldDescriptor{Name: "resource_name", InputKey: "resource_name"},
	ReviewedBy:                    FieldDescriptor{Name: "reviewed_by", InputKey: "reviewed_by"},
	ReviewedByGroupID:             FieldDescriptor{Name: "reviewed_by_group_id", InputKey: "reviewed_by_group_id"},
	ReviewedByIdentityHolderID:    FieldDescriptor{Name: "reviewed_by_identity_holder_id", InputKey: "reviewed_by_identity_holder_id"},
	ReviewedByUserID:              FieldDescriptor{Name: "reviewed_by_user_id", InputKey: "reviewed_by_user_id"},
	ScopeID:                       FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:                     FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	Score:                         FieldDescriptor{Name: "score", InputKey: "score"},
	Severity:                      FieldDescriptor{Name: "severity", InputKey: "severity"},
	Source:                        FieldDescriptor{Name: "source", InputKey: "source"},
	SourceUpdatedAt:               FieldDescriptor{Name: "source_updated_at", InputKey: "source_updated_at"},
	State:                         FieldDescriptor{Name: "state", InputKey: "state"},
	StepsToReproduce:              FieldDescriptor{Name: "steps_to_reproduce", InputKey: "steps_to_reproduce"},
	SystemInternalID:              FieldDescriptor{Name: "system_internal_id", InputKey: "system_internal_id"},
	Tags:                          FieldDescriptor{Name: "tags", InputKey: "tags"},
	TargetDetails:                 FieldDescriptor{Name: "target_details", InputKey: "target_details"},
	Targets:                       FieldDescriptor{Name: "targets", InputKey: "targets"},
	Validated:                     FieldDescriptor{Name: "validated", InputKey: "validated"},
	Vector:                        FieldDescriptor{Name: "vector", InputKey: "vector"},
}

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

var InternalPolicyFields = struct {
	// ApprovalRequired is the approval_required field
	ApprovalRequired FieldDescriptor
	// ApproverID is the approver_id field
	ApproverID FieldDescriptor
	// ControlSuggestions is the control_suggestions field
	ControlSuggestions FieldDescriptor
	// DelegateID is the delegate_id field
	DelegateID FieldDescriptor
	// Details is the details field
	Details FieldDescriptor
	// DetailsJSON is the details_json field
	DetailsJSON FieldDescriptor
	// DismissedControlSuggestions is the dismissed_control_suggestions field
	DismissedControlSuggestions FieldDescriptor
	// DismissedImprovementSuggestions is the dismissed_improvement_suggestions field
	DismissedImprovementSuggestions FieldDescriptor
	// DismissedTagSuggestions is the dismissed_tag_suggestions field
	DismissedTagSuggestions FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// ExternalContents is the external_contents field
	ExternalContents FieldDescriptor
	// ExternalFileID is the external_file_id field
	ExternalFileID FieldDescriptor
	// ExternalUUID is the external_uuid field
	ExternalUUID FieldDescriptor
	// ImprovementSuggestions is the improvement_suggestions field
	ImprovementSuggestions FieldDescriptor
	// InternalNotes is the internal_notes field
	InternalNotes FieldDescriptor
	// InternalPolicyKindID is the internal_policy_kind_id field
	InternalPolicyKindID FieldDescriptor
	// InternalPolicyKindName is the internal_policy_kind_name field
	InternalPolicyKindName FieldDescriptor
	// ManagementMode is the management_mode field
	ManagementMode FieldDescriptor
	// Name is the name field
	Name FieldDescriptor
	// ReviewDue is the review_due field
	ReviewDue FieldDescriptor
	// ReviewFrequency is the review_frequency field
	ReviewFrequency FieldDescriptor
	// Revision is the revision field
	Revision FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// Status is the status field
	Status FieldDescriptor
	// SystemInternalID is the system_internal_id field
	SystemInternalID FieldDescriptor
	// TagSuggestions is the tag_suggestions field
	TagSuggestions FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
	// URL is the url field
	URL FieldDescriptor
}{
	ApprovalRequired:                FieldDescriptor{Name: "approval_required", InputKey: "approval_required"},
	ApproverID:                      FieldDescriptor{Name: "approver_id", InputKey: "approver_id"},
	ControlSuggestions:              FieldDescriptor{Name: "control_suggestions", InputKey: "control_suggestions"},
	DelegateID:                      FieldDescriptor{Name: "delegate_id", InputKey: "delegate_id"},
	Details:                         FieldDescriptor{Name: "details", InputKey: "details"},
	DetailsJSON:                     FieldDescriptor{Name: "details_json", InputKey: "details_json"},
	DismissedControlSuggestions:     FieldDescriptor{Name: "dismissed_control_suggestions", InputKey: "dismissed_control_suggestions"},
	DismissedImprovementSuggestions: FieldDescriptor{Name: "dismissed_improvement_suggestions", InputKey: "dismissed_improvement_suggestions"},
	DismissedTagSuggestions:         FieldDescriptor{Name: "dismissed_tag_suggestions", InputKey: "dismissed_tag_suggestions"},
	EnvironmentID:                   FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:                 FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	ExternalContents:                FieldDescriptor{Name: "external_contents", InputKey: "external_contents"},
	ExternalFileID:                  FieldDescriptor{Name: "external_file_id", InputKey: "external_file_id"},
	ExternalUUID:                    FieldDescriptor{Name: "external_uuid", InputKey: "external_uuid"},
	ImprovementSuggestions:          FieldDescriptor{Name: "improvement_suggestions", InputKey: "improvement_suggestions"},
	InternalNotes:                   FieldDescriptor{Name: "internal_notes", InputKey: "internal_notes"},
	InternalPolicyKindID:            FieldDescriptor{Name: "internal_policy_kind_id", InputKey: "internal_policy_kind_id"},
	InternalPolicyKindName:          FieldDescriptor{Name: "internal_policy_kind_name", InputKey: "internal_policy_kind_name"},
	ManagementMode:                  FieldDescriptor{Name: "management_mode", InputKey: "management_mode"},
	Name:                            FieldDescriptor{Name: "name", InputKey: "name"},
	ReviewDue:                       FieldDescriptor{Name: "review_due", InputKey: "review_due"},
	ReviewFrequency:                 FieldDescriptor{Name: "review_frequency", InputKey: "review_frequency"},
	Revision:                        FieldDescriptor{Name: "revision", InputKey: "revision"},
	ScopeID:                         FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:                       FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	Status:                          FieldDescriptor{Name: "status", InputKey: "status"},
	SystemInternalID:                FieldDescriptor{Name: "system_internal_id", InputKey: "system_internal_id"},
	TagSuggestions:                  FieldDescriptor{Name: "tag_suggestions", InputKey: "tag_suggestions"},
	Tags:                            FieldDescriptor{Name: "tags", InputKey: "tags"},
	URL:                             FieldDescriptor{Name: "url", InputKey: "url"},
}

var ProcedureFields = struct {
	// ApprovalRequired is the approval_required field
	ApprovalRequired FieldDescriptor
	// ApproverID is the approver_id field
	ApproverID FieldDescriptor
	// ControlSuggestions is the control_suggestions field
	ControlSuggestions FieldDescriptor
	// DelegateID is the delegate_id field
	DelegateID FieldDescriptor
	// Details is the details field
	Details FieldDescriptor
	// DetailsJSON is the details_json field
	DetailsJSON FieldDescriptor
	// DismissedControlSuggestions is the dismissed_control_suggestions field
	DismissedControlSuggestions FieldDescriptor
	// DismissedImprovementSuggestions is the dismissed_improvement_suggestions field
	DismissedImprovementSuggestions FieldDescriptor
	// DismissedTagSuggestions is the dismissed_tag_suggestions field
	DismissedTagSuggestions FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// ExternalContents is the external_contents field
	ExternalContents FieldDescriptor
	// ExternalFileID is the external_file_id field
	ExternalFileID FieldDescriptor
	// ImprovementSuggestions is the improvement_suggestions field
	ImprovementSuggestions FieldDescriptor
	// InternalNotes is the internal_notes field
	InternalNotes FieldDescriptor
	// ManagementMode is the management_mode field
	ManagementMode FieldDescriptor
	// Name is the name field
	Name FieldDescriptor
	// ProcedureKindID is the procedure_kind_id field
	ProcedureKindID FieldDescriptor
	// ProcedureKindName is the procedure_kind_name field
	ProcedureKindName FieldDescriptor
	// ReviewDue is the review_due field
	ReviewDue FieldDescriptor
	// ReviewFrequency is the review_frequency field
	ReviewFrequency FieldDescriptor
	// Revision is the revision field
	Revision FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// Status is the status field
	Status FieldDescriptor
	// SystemInternalID is the system_internal_id field
	SystemInternalID FieldDescriptor
	// TagSuggestions is the tag_suggestions field
	TagSuggestions FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
	// URL is the url field
	URL FieldDescriptor
}{
	ApprovalRequired:                FieldDescriptor{Name: "approval_required", InputKey: "approval_required"},
	ApproverID:                      FieldDescriptor{Name: "approver_id", InputKey: "approver_id"},
	ControlSuggestions:              FieldDescriptor{Name: "control_suggestions", InputKey: "control_suggestions"},
	DelegateID:                      FieldDescriptor{Name: "delegate_id", InputKey: "delegate_id"},
	Details:                         FieldDescriptor{Name: "details", InputKey: "details"},
	DetailsJSON:                     FieldDescriptor{Name: "details_json", InputKey: "details_json"},
	DismissedControlSuggestions:     FieldDescriptor{Name: "dismissed_control_suggestions", InputKey: "dismissed_control_suggestions"},
	DismissedImprovementSuggestions: FieldDescriptor{Name: "dismissed_improvement_suggestions", InputKey: "dismissed_improvement_suggestions"},
	DismissedTagSuggestions:         FieldDescriptor{Name: "dismissed_tag_suggestions", InputKey: "dismissed_tag_suggestions"},
	EnvironmentID:                   FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:                 FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	ExternalContents:                FieldDescriptor{Name: "external_contents", InputKey: "external_contents"},
	ExternalFileID:                  FieldDescriptor{Name: "external_file_id", InputKey: "external_file_id"},
	ImprovementSuggestions:          FieldDescriptor{Name: "improvement_suggestions", InputKey: "improvement_suggestions"},
	InternalNotes:                   FieldDescriptor{Name: "internal_notes", InputKey: "internal_notes"},
	ManagementMode:                  FieldDescriptor{Name: "management_mode", InputKey: "management_mode"},
	Name:                            FieldDescriptor{Name: "name", InputKey: "name"},
	ProcedureKindID:                 FieldDescriptor{Name: "procedure_kind_id", InputKey: "procedure_kind_id"},
	ProcedureKindName:               FieldDescriptor{Name: "procedure_kind_name", InputKey: "procedure_kind_name"},
	ReviewDue:                       FieldDescriptor{Name: "review_due", InputKey: "review_due"},
	ReviewFrequency:                 FieldDescriptor{Name: "review_frequency", InputKey: "review_frequency"},
	Revision:                        FieldDescriptor{Name: "revision", InputKey: "revision"},
	ScopeID:                         FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:                       FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	Status:                          FieldDescriptor{Name: "status", InputKey: "status"},
	SystemInternalID:                FieldDescriptor{Name: "system_internal_id", InputKey: "system_internal_id"},
	TagSuggestions:                  FieldDescriptor{Name: "tag_suggestions", InputKey: "tag_suggestions"},
	Tags:                            FieldDescriptor{Name: "tags", InputKey: "tags"},
	URL:                             FieldDescriptor{Name: "url", InputKey: "url"},
}

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

var RiskFields = struct {
	// BusinessCosts is the business_costs field
	BusinessCosts FieldDescriptor
	// BusinessCostsJSON is the business_costs_json field
	BusinessCostsJSON FieldDescriptor
	// DelegateGroupID is the delegate_group_id field
	DelegateGroupID FieldDescriptor
	// DelegateIdentityHolderID is the delegate_identity_holder_id field
	DelegateIdentityHolderID FieldDescriptor
	// DelegateName is the delegate_name field
	DelegateName FieldDescriptor
	// DelegateUserID is the delegate_user_id field
	DelegateUserID FieldDescriptor
	// Details is the details field
	Details FieldDescriptor
	// DetailsJSON is the details_json field
	DetailsJSON FieldDescriptor
	// DueDate is the due_date field
	DueDate FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// ExternalID is the external_id field
	ExternalID FieldDescriptor
	// ExternalUUID is the external_uuid field
	ExternalUUID FieldDescriptor
	// Impact is the impact field
	Impact FieldDescriptor
	// LastReviewedAt is the last_reviewed_at field
	LastReviewedAt FieldDescriptor
	// Likelihood is the likelihood field
	Likelihood FieldDescriptor
	// MitigatedAt is the mitigated_at field
	MitigatedAt FieldDescriptor
	// Mitigation is the mitigation field
	Mitigation FieldDescriptor
	// MitigationJSON is the mitigation_json field
	MitigationJSON FieldDescriptor
	// Name is the name field
	Name FieldDescriptor
	// NextReviewDueAt is the next_review_due_at field
	NextReviewDueAt FieldDescriptor
	// ObservedAt is the observed_at field
	ObservedAt FieldDescriptor
	// ResidualScore is the residual_score field
	ResidualScore FieldDescriptor
	// ReviewFrequency is the review_frequency field
	ReviewFrequency FieldDescriptor
	// ReviewRequired is the review_required field
	ReviewRequired FieldDescriptor
	// RiskCategoryID is the risk_category_id field
	RiskCategoryID FieldDescriptor
	// RiskCategoryName is the risk_category_name field
	RiskCategoryName FieldDescriptor
	// RiskDecision is the risk_decision field
	RiskDecision FieldDescriptor
	// RiskKindID is the risk_kind_id field
	RiskKindID FieldDescriptor
	// RiskKindName is the risk_kind_name field
	RiskKindName FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// Score is the score field
	Score FieldDescriptor
	// StakeholderGroupID is the stakeholder_group_id field
	StakeholderGroupID FieldDescriptor
	// StakeholderIdentityHolderID is the stakeholder_identity_holder_id field
	StakeholderIdentityHolderID FieldDescriptor
	// StakeholderName is the stakeholder_name field
	StakeholderName FieldDescriptor
	// StakeholderUserID is the stakeholder_user_id field
	StakeholderUserID FieldDescriptor
	// Status is the status field
	Status FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
}{
	BusinessCosts:               FieldDescriptor{Name: "business_costs", InputKey: "business_costs"},
	BusinessCostsJSON:           FieldDescriptor{Name: "business_costs_json", InputKey: "business_costs_json"},
	DelegateGroupID:             FieldDescriptor{Name: "delegate_group_id", InputKey: "delegate_group_id"},
	DelegateIdentityHolderID:    FieldDescriptor{Name: "delegate_identity_holder_id", InputKey: "delegate_identity_holder_id"},
	DelegateName:                FieldDescriptor{Name: "delegate_name", InputKey: "delegate_name"},
	DelegateUserID:              FieldDescriptor{Name: "delegate_user_id", InputKey: "delegate_user_id"},
	Details:                     FieldDescriptor{Name: "details", InputKey: "details"},
	DetailsJSON:                 FieldDescriptor{Name: "details_json", InputKey: "details_json"},
	DueDate:                     FieldDescriptor{Name: "due_date", InputKey: "due_date"},
	EnvironmentID:               FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:             FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	ExternalID:                  FieldDescriptor{Name: "external_id", InputKey: "external_id"},
	ExternalUUID:                FieldDescriptor{Name: "external_uuid", InputKey: "external_uuid"},
	Impact:                      FieldDescriptor{Name: "impact", InputKey: "impact"},
	LastReviewedAt:              FieldDescriptor{Name: "last_reviewed_at", InputKey: "last_reviewed_at"},
	Likelihood:                  FieldDescriptor{Name: "likelihood", InputKey: "likelihood"},
	MitigatedAt:                 FieldDescriptor{Name: "mitigated_at", InputKey: "mitigated_at"},
	Mitigation:                  FieldDescriptor{Name: "mitigation", InputKey: "mitigation"},
	MitigationJSON:              FieldDescriptor{Name: "mitigation_json", InputKey: "mitigation_json"},
	Name:                        FieldDescriptor{Name: "name", InputKey: "name"},
	NextReviewDueAt:             FieldDescriptor{Name: "next_review_due_at", InputKey: "next_review_due_at"},
	ObservedAt:                  FieldDescriptor{Name: "observed_at", InputKey: "observed_at"},
	ResidualScore:               FieldDescriptor{Name: "residual_score", InputKey: "residual_score"},
	ReviewFrequency:             FieldDescriptor{Name: "review_frequency", InputKey: "review_frequency"},
	ReviewRequired:              FieldDescriptor{Name: "review_required", InputKey: "review_required"},
	RiskCategoryID:              FieldDescriptor{Name: "risk_category_id", InputKey: "risk_category_id"},
	RiskCategoryName:            FieldDescriptor{Name: "risk_category_name", InputKey: "risk_category_name"},
	RiskDecision:                FieldDescriptor{Name: "risk_decision", InputKey: "risk_decision"},
	RiskKindID:                  FieldDescriptor{Name: "risk_kind_id", InputKey: "risk_kind_id"},
	RiskKindName:                FieldDescriptor{Name: "risk_kind_name", InputKey: "risk_kind_name"},
	ScopeID:                     FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:                   FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	Score:                       FieldDescriptor{Name: "score", InputKey: "score"},
	StakeholderGroupID:          FieldDescriptor{Name: "stakeholder_group_id", InputKey: "stakeholder_group_id"},
	StakeholderIdentityHolderID: FieldDescriptor{Name: "stakeholder_identity_holder_id", InputKey: "stakeholder_identity_holder_id"},
	StakeholderName:             FieldDescriptor{Name: "stakeholder_name", InputKey: "stakeholder_name"},
	StakeholderUserID:           FieldDescriptor{Name: "stakeholder_user_id", InputKey: "stakeholder_user_id"},
	Status:                      FieldDescriptor{Name: "status", InputKey: "status"},
	Tags:                        FieldDescriptor{Name: "tags", InputKey: "tags"},
}

var VulnerabilityFields = struct {
	// AssignedTo is the assigned_to field
	AssignedTo FieldDescriptor
	// AssignedToGroupID is the assigned_to_group_id field
	AssignedToGroupID FieldDescriptor
	// AssignedToIdentityHolderID is the assigned_to_identity_holder_id field
	AssignedToIdentityHolderID FieldDescriptor
	// AssignedToUserID is the assigned_to_user_id field
	AssignedToUserID FieldDescriptor
	// AutoDismissedAt is the auto_dismissed_at field
	AutoDismissedAt FieldDescriptor
	// Blocking is the blocking field
	Blocking FieldDescriptor
	// Category is the category field
	Category FieldDescriptor
	// CveID is the cve_id field
	CveID FieldDescriptor
	// CweIds is the cwe_ids field
	CweIds FieldDescriptor
	// DependencyScope is the dependency_scope field
	DependencyScope FieldDescriptor
	// Description is the description field
	Description FieldDescriptor
	// DiscoveredAt is the discovered_at field
	DiscoveredAt FieldDescriptor
	// DismissedAt is the dismissed_at field
	DismissedAt FieldDescriptor
	// DismissedComment is the dismissed_comment field
	DismissedComment FieldDescriptor
	// DismissedReason is the dismissed_reason field
	DismissedReason FieldDescriptor
	// DisplayName is the display_name field
	DisplayName FieldDescriptor
	// EnvironmentID is the environment_id field
	EnvironmentID FieldDescriptor
	// EnvironmentName is the environment_name field
	EnvironmentName FieldDescriptor
	// Exploitability is the exploitability field
	Exploitability FieldDescriptor
	// ExternalID is the external_id field
	ExternalID FieldDescriptor
	// ExternalOwnerID is the external_owner_id field
	ExternalOwnerID FieldDescriptor
	// ExternalURI is the external_uri field
	ExternalURI FieldDescriptor
	// FirstPatchedVersion is the first_patched_version field
	FirstPatchedVersion FieldDescriptor
	// FixAvailable is the fix_available field
	FixAvailable FieldDescriptor
	// FixedAt is the fixed_at field
	FixedAt FieldDescriptor
	// Impact is the impact field
	Impact FieldDescriptor
	// Impacts is the impacts field
	Impacts FieldDescriptor
	// InternalNotes is the internal_notes field
	InternalNotes FieldDescriptor
	// InternalOwner is the internal_owner field
	InternalOwner FieldDescriptor
	// InternalOwnerGroupID is the internal_owner_group_id field
	InternalOwnerGroupID FieldDescriptor
	// InternalOwnerIdentityHolderID is the internal_owner_identity_holder_id field
	InternalOwnerIdentityHolderID FieldDescriptor
	// InternalOwnerUserID is the internal_owner_user_id field
	InternalOwnerUserID FieldDescriptor
	// ManifestPath is the manifest_path field
	ManifestPath FieldDescriptor
	// Metadata is the metadata field
	Metadata FieldDescriptor
	// Open is the open field
	Open FieldDescriptor
	// PackageEcosystem is the package_ecosystem field
	PackageEcosystem FieldDescriptor
	// PackageName is the package_name field
	PackageName FieldDescriptor
	// Priority is the priority field
	Priority FieldDescriptor
	// Production is the production field
	Production FieldDescriptor
	// Public is the public field
	Public FieldDescriptor
	// PublishedAt is the published_at field
	PublishedAt FieldDescriptor
	// RawPayload is the raw_payload field
	RawPayload FieldDescriptor
	// References is the references field
	References FieldDescriptor
	// RemediationSLA is the remediation_sla field
	RemediationSLA FieldDescriptor
	// ReviewedBy is the reviewed_by field
	ReviewedBy FieldDescriptor
	// ReviewedByGroupID is the reviewed_by_group_id field
	ReviewedByGroupID FieldDescriptor
	// ReviewedByIdentityHolderID is the reviewed_by_identity_holder_id field
	ReviewedByIdentityHolderID FieldDescriptor
	// ReviewedByUserID is the reviewed_by_user_id field
	ReviewedByUserID FieldDescriptor
	// ScopeID is the scope_id field
	ScopeID FieldDescriptor
	// ScopeName is the scope_name field
	ScopeName FieldDescriptor
	// Score is the score field
	Score FieldDescriptor
	// Severity is the severity field
	Severity FieldDescriptor
	// Source is the source field
	Source FieldDescriptor
	// SourceUpdatedAt is the source_updated_at field
	SourceUpdatedAt FieldDescriptor
	// Summary is the summary field
	Summary FieldDescriptor
	// SystemInternalID is the system_internal_id field
	SystemInternalID FieldDescriptor
	// Tags is the tags field
	Tags FieldDescriptor
	// Validated is the validated field
	Validated FieldDescriptor
	// Vector is the vector field
	Vector FieldDescriptor
	// VulnerabilityStatusID is the vulnerability_status_id field
	VulnerabilityStatusID FieldDescriptor
	// VulnerabilityStatusName is the vulnerability_status_name field
	VulnerabilityStatusName FieldDescriptor
	// VulnerableVersionRange is the vulnerable_version_range field
	VulnerableVersionRange FieldDescriptor
}{
	AssignedTo:                    FieldDescriptor{Name: "assigned_to", InputKey: "assigned_to"},
	AssignedToGroupID:             FieldDescriptor{Name: "assigned_to_group_id", InputKey: "assigned_to_group_id"},
	AssignedToIdentityHolderID:    FieldDescriptor{Name: "assigned_to_identity_holder_id", InputKey: "assigned_to_identity_holder_id"},
	AssignedToUserID:              FieldDescriptor{Name: "assigned_to_user_id", InputKey: "assigned_to_user_id"},
	AutoDismissedAt:               FieldDescriptor{Name: "auto_dismissed_at", InputKey: "auto_dismissed_at"},
	Blocking:                      FieldDescriptor{Name: "blocking", InputKey: "blocking"},
	Category:                      FieldDescriptor{Name: "category", InputKey: "category"},
	CveID:                         FieldDescriptor{Name: "cve_id", InputKey: "cve_id"},
	CweIds:                        FieldDescriptor{Name: "cwe_ids", InputKey: "cwe_ids"},
	DependencyScope:               FieldDescriptor{Name: "dependency_scope", InputKey: "dependency_scope"},
	Description:                   FieldDescriptor{Name: "description", InputKey: "description"},
	DiscoveredAt:                  FieldDescriptor{Name: "discovered_at", InputKey: "discovered_at"},
	DismissedAt:                   FieldDescriptor{Name: "dismissed_at", InputKey: "dismissed_at"},
	DismissedComment:              FieldDescriptor{Name: "dismissed_comment", InputKey: "dismissed_comment"},
	DismissedReason:               FieldDescriptor{Name: "dismissed_reason", InputKey: "dismissed_reason"},
	DisplayName:                   FieldDescriptor{Name: "display_name", InputKey: "display_name"},
	EnvironmentID:                 FieldDescriptor{Name: "environment_id", InputKey: "environment_id"},
	EnvironmentName:               FieldDescriptor{Name: "environment_name", InputKey: "environment_name"},
	Exploitability:                FieldDescriptor{Name: "exploitability", InputKey: "exploitability"},
	ExternalID:                    FieldDescriptor{Name: "external_id", InputKey: "external_id"},
	ExternalOwnerID:               FieldDescriptor{Name: "external_owner_id", InputKey: "external_owner_id"},
	ExternalURI:                   FieldDescriptor{Name: "external_uri", InputKey: "external_uri"},
	FirstPatchedVersion:           FieldDescriptor{Name: "first_patched_version", InputKey: "first_patched_version"},
	FixAvailable:                  FieldDescriptor{Name: "fix_available", InputKey: "fix_available"},
	FixedAt:                       FieldDescriptor{Name: "fixed_at", InputKey: "fixed_at"},
	Impact:                        FieldDescriptor{Name: "impact", InputKey: "impact"},
	Impacts:                       FieldDescriptor{Name: "impacts", InputKey: "impacts"},
	InternalNotes:                 FieldDescriptor{Name: "internal_notes", InputKey: "internal_notes"},
	InternalOwner:                 FieldDescriptor{Name: "internal_owner", InputKey: "internal_owner"},
	InternalOwnerGroupID:          FieldDescriptor{Name: "internal_owner_group_id", InputKey: "internal_owner_group_id"},
	InternalOwnerIdentityHolderID: FieldDescriptor{Name: "internal_owner_identity_holder_id", InputKey: "internal_owner_identity_holder_id"},
	InternalOwnerUserID:           FieldDescriptor{Name: "internal_owner_user_id", InputKey: "internal_owner_user_id"},
	ManifestPath:                  FieldDescriptor{Name: "manifest_path", InputKey: "manifest_path"},
	Metadata:                      FieldDescriptor{Name: "metadata", InputKey: "metadata"},
	Open:                          FieldDescriptor{Name: "open", InputKey: "open"},
	PackageEcosystem:              FieldDescriptor{Name: "package_ecosystem", InputKey: "package_ecosystem"},
	PackageName:                   FieldDescriptor{Name: "package_name", InputKey: "package_name"},
	Priority:                      FieldDescriptor{Name: "priority", InputKey: "priority"},
	Production:                    FieldDescriptor{Name: "production", InputKey: "production"},
	Public:                        FieldDescriptor{Name: "public", InputKey: "public"},
	PublishedAt:                   FieldDescriptor{Name: "published_at", InputKey: "published_at"},
	RawPayload:                    FieldDescriptor{Name: "raw_payload", InputKey: "raw_payload"},
	References:                    FieldDescriptor{Name: "references", InputKey: "references"},
	RemediationSLA:                FieldDescriptor{Name: "remediation_sla", InputKey: "remediation_sla"},
	ReviewedBy:                    FieldDescriptor{Name: "reviewed_by", InputKey: "reviewed_by"},
	ReviewedByGroupID:             FieldDescriptor{Name: "reviewed_by_group_id", InputKey: "reviewed_by_group_id"},
	ReviewedByIdentityHolderID:    FieldDescriptor{Name: "reviewed_by_identity_holder_id", InputKey: "reviewed_by_identity_holder_id"},
	ReviewedByUserID:              FieldDescriptor{Name: "reviewed_by_user_id", InputKey: "reviewed_by_user_id"},
	ScopeID:                       FieldDescriptor{Name: "scope_id", InputKey: "scope_id"},
	ScopeName:                     FieldDescriptor{Name: "scope_name", InputKey: "scope_name"},
	Score:                         FieldDescriptor{Name: "score", InputKey: "score"},
	Severity:                      FieldDescriptor{Name: "severity", InputKey: "severity"},
	Source:                        FieldDescriptor{Name: "source", InputKey: "source"},
	SourceUpdatedAt:               FieldDescriptor{Name: "source_updated_at", InputKey: "source_updated_at"},
	Summary:                       FieldDescriptor{Name: "summary", InputKey: "summary"},
	SystemInternalID:              FieldDescriptor{Name: "system_internal_id", InputKey: "system_internal_id"},
	Tags:                          FieldDescriptor{Name: "tags", InputKey: "tags"},
	Validated:                     FieldDescriptor{Name: "validated", InputKey: "validated"},
	Vector:                        FieldDescriptor{Name: "vector", InputKey: "vector"},
	VulnerabilityStatusID:         FieldDescriptor{Name: "vulnerability_status_id", InputKey: "vulnerability_status_id"},
	VulnerabilityStatusName:       FieldDescriptor{Name: "vulnerability_status_name", InputKey: "vulnerability_status_name"},
	VulnerableVersionRange:        FieldDescriptor{Name: "vulnerable_version_range", InputKey: "vulnerable_version_range"},
}