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")
	// ErrCatalogUnsupported indicates the schema has no catalog adoption capability
	ErrCatalogUnsupported = errors.New("entityops: catalog unsupported")
	// ErrCatalogRowNotSystemOwned indicates the catalog row does not exist or is not system owned
	ErrCatalogRowNotSystemOwned = errors.New("entityops: catalog row not system owned")
	// ErrCatalogRowNotVisible indicates the catalog row is system owned but not visible to organizations
	ErrCatalogRowNotVisible = errors.New("entityops: catalog row not visible")
	// ErrCatalogMatchFieldUnsupported indicates a match candidate names a field that is not a matchable string or string-array column
	ErrCatalogMatchFieldUnsupported = errors.New("entityops: catalog match field unsupported")
)

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",
		},
		OwnerField: apitoken.FieldOwnerID,
		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"},
		OwnerField:            actionplan.FieldOwnerID,
		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(ownerScopeActionPlan(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](),
		OwnerField:     assessment.FieldOwnerID,
		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
		},
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "assessment", Operation: refOpQuery}

			entities, err := client.Assessment.Query().
				Where(ownerScopeAssessment(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", 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
		},
	}
	SchemaAssessmentPolicy = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:  "AssessmentPolicy",
			Snake: "assessment_policy",
			Lower: "assessmentpolicy",
		},
		ProjectionType: reflect.TypeFor[AssessmentPolicyProjection](),
		OwnerField:     assessmentpolicy.FieldOwnerID,
		Query: func(ctx context.Context, client *generated.Client, orgID string) ([]json.RawMessage, error) {
			ref := SchemaRef{Schema: "assessment_policy", Operation: refOpQuery}

			entities, err := client.AssessmentPolicy.Query().
				Where(assessmentpolicy.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_policy", Operation: refOpLoad, EntityID: entityID}

			entity, err := client.AssessmentPolicy.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
		},
	}
	SchemaAssessmentResponse = &Schema{
		SchemaDescriptor: SchemaDescriptor{
			Name:             "AssessmentResponse",
			Snake:            "assessment_response",
			Lower:            "assessmentresponse",
			WorkflowEligible: true,
		},
		ProjectionType: reflect.TypeFor[AssessmentResponseProjection](),
		OwnerField:     assessmentresponse.FieldOwnerID,
		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](),
		OwnerField:            asset.FieldOwnerID,
		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(ownerScopeAsset(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](),
		OwnerField:         campaign.FieldOwnerID,
		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](),
		OwnerField:     campaigntarget.FieldOwnerID,
		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](),
		OwnerField:            contact.FieldOwnerID,
		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"},
		OwnerField:     control.FieldOwnerID,
		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(ownerScopeControl(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](),
		OwnerField:     controlimplementation.FieldOwnerID,
		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(ownerScopeControlImplementation(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](),
		OwnerField:     controlobjective.FieldOwnerID,
		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(ownerScopeControlObjective(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",
		},
		OwnerField: customdomain.FieldOwnerID,
		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](),
		OwnerField:     customtypeenum.FieldOwnerID,
		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(ownerScopeCustomTypeEnum(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",
		},
		OwnerField: dnsverification.FieldOwnerID,
		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](),
		OwnerField:            directoryaccount.FieldOwnerID,
		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](),
		OwnerField:            directorygroup.FieldOwnerID,
		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](),
		OwnerField:            directorymembership.FieldOwnerID,
		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](),
		OwnerField:     discussion.FieldOwnerID,
		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](),
		OwnerField:     documentdata.FieldOwnerID,
		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",
		},
		OwnerField:         emailtemplate.FieldOwnerID,
		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](),
		OwnerField:            entity.FieldOwnerID,
		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(ownerScopeEntity(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](),
		OwnerField:     entitytype.FieldOwnerID,
		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(ownerScopeEntityType(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"},
		OwnerField:     evidence.FieldOwnerID,
		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",
		},
		OwnerField: export.FieldOwnerID,
		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](),
		OwnerField:            finding.FieldOwnerID,
		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(ownerScopeFinding(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](),
		OwnerField:     findingcontrol.FieldOwnerID,
		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](),
		OwnerField:         group.FieldOwnerID,
		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",
		},
		OwnerField:         hush.FieldOwnerID,
		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](),
		OwnerField:     identityholder.FieldOwnerID,
		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"},
		OwnerField:            integration.FieldOwnerID,
		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(ownerScopeIntegration(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](),
		OwnerField:         integrationrun.FieldOwnerID,
		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",
		},
		OwnerField:         integrationwebhook.FieldOwnerID,
		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"},
		OwnerField:            internalpolicy.FieldOwnerID,
		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(ownerScopeInternalPolicy(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",
		},
		OwnerField: invite.FieldOwnerID,
		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",
		},
		OwnerField: mappedcontrol.FieldOwnerID,
		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](),
		OwnerField:     narrative.FieldOwnerID,
		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(ownerScopeNarrative(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"},
		OwnerField:     note.FieldOwnerID,
		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",
		},
		OwnerField: notification.FieldOwnerID,
		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",
		},
		OwnerField: notificationpreference.FieldOwnerID,
		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",
		},
		OwnerField:         notificationtemplate.FieldOwnerID,
		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",
		},
		OwnerField: orgmodule.FieldOwnerID,
		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",
		},
		OwnerField: orgprice.FieldOwnerID,
		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",
		},
		OwnerField: orgproduct.FieldOwnerID,
		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",
		},
		OwnerField: orgsubscription.FieldOwnerID,
		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](),
		OwnerField:         platform.FieldOwnerID,
		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"},
		OwnerField:            procedure.FieldOwnerID,
		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(ownerScopeProcedure(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"},
		OwnerField:     program.FieldOwnerID,
		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](),
		OwnerField:         remediation.FieldOwnerID,
		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(ownerScopeRemediation(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](),
		OwnerField:         review.FieldOwnerID,
		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(ownerScopeReview(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"},
		OwnerField:            risk.FieldOwnerID,
		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",
		},
		OwnerField: sladefinition.FieldOwnerID,
		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](),
		OwnerField:     scan.FieldOwnerID,
		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(ownerScopeScan(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"},
		OwnerField:   standard.FieldOwnerID,
		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](),
		OwnerField:     subcontrol.FieldOwnerID,
		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(ownerScopeSubcontrol(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](),
		OwnerField:     subprocessor.FieldOwnerID,
		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(ownerScopeSubprocessor(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](),
		AnonymousInputFields: []string{"trustCenterID", "email"},
		OwnerField:           subscriber.FieldOwnerID,
		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](),
		OwnerField:     systemdetail.FieldOwnerID,
		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",
		},
		OwnerField: tagdefinition.FieldOwnerID,
		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"},
		OwnerField:     task.FieldOwnerID,
		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",
		},
		OwnerField: template.FieldOwnerID,
		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",
		},
		ConsoleRoute: &ConsoleRoute{Base: "trust-center"},
		OwnerField:   trustcenter.FieldOwnerID,
		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",
		},
		AnonymousInputFields: []string{"trustCenterID", "firstName", "lastName", "email", "companyName", "reason", "accessLevel"},
		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",
		},
		OwnerField: trustcenterwatermarkconfig.FieldOwnerID,
		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](),
		OwnerField:     vendorriskscore.FieldOwnerID,
		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",
		},
		OwnerField: vendorscoringconfig.FieldOwnerID,
		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](),
		OwnerField:            vulnerability.FieldOwnerID,
		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(ownerScopeVulnerability(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",
		},
		OwnerField: workflowassignment.FieldOwnerID,
		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",
		},
		OwnerField: workflowassignmenttarget.FieldOwnerID,
		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",
		},
		OwnerField: workflowdefinition.FieldOwnerID,
		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",
		},
		OwnerField: workflowevent.FieldOwnerID,
		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",
		},
		OwnerField:         workflowinstance.FieldOwnerID,
		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](),
		OwnerField:     workflowobjectref.FieldOwnerID,
		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",
		},
		OwnerField: workflowproposal.FieldOwnerID,
		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", Label: "ActionPlanKindID", Type: "string", MatchKey: true, InputKey: "action_plan_kind_id", Clearable: true},
	ActionPlanKindName:              FieldDescriptor{Name: "action_plan_kind_name", Label: "ActionPlanKindName", Type: "string", MatchKey: true, InputKey: "action_plan_kind_name", Clearable: true, CaseInsensitive: true},
	ApprovalRequired:                FieldDescriptor{Name: "approval_required", Label: "ApprovalRequired", Type: "bool", InputKey: "approval_required", Clearable: true},
	ApproverID:                      FieldDescriptor{Name: "approver_id", Label: "ApproverID", Type: "string", MatchKey: true, InputKey: "approver_id", Clearable: true},
	Blocked:                         FieldDescriptor{Name: "blocked", Label: "Blocked", Type: "bool", InputKey: "blocked"},
	BlockerReason:                   FieldDescriptor{Name: "blocker_reason", Label: "BlockerReason", Type: "string", MatchKey: true, InputKey: "blocker_reason", Clearable: true},
	CompletedAt:                     FieldDescriptor{Name: "completed_at", Label: "CompletedAt", Type: "time.Time", InputKey: "completed_at", Clearable: true},
	ControlSuggestions:              FieldDescriptor{Name: "control_suggestions", Label: "ControlSuggestions", Type: "[]string", InputKey: "control_suggestions", Clearable: true},
	DelegateID:                      FieldDescriptor{Name: "delegate_id", Label: "DelegateID", Type: "string", MatchKey: true, InputKey: "delegate_id", Clearable: true},
	Description:                     FieldDescriptor{Name: "description", Label: "Description", Type: "string", MatchKey: true, InputKey: "description", Clearable: true},
	Details:                         FieldDescriptor{Name: "details", Label: "Details", Type: "string", WorkflowEligible: true, MatchKey: true, InputKey: "details", Clearable: true},
	DetailsJSON:                     FieldDescriptor{Name: "details_json", Label: "DetailsJSON", Type: "[]interface {}", WorkflowEligible: true, InputKey: "details_json", Clearable: true},
	DismissedControlSuggestions:     FieldDescriptor{Name: "dismissed_control_suggestions", Label: "DismissedControlSuggestions", Type: "[]string", InputKey: "dismissed_control_suggestions", Clearable: true},
	DismissedImprovementSuggestions: FieldDescriptor{Name: "dismissed_improvement_suggestions", Label: "DismissedImprovementSuggestions", Type: "[]string", InputKey: "dismissed_improvement_suggestions", Clearable: true},
	DismissedTagSuggestions:         FieldDescriptor{Name: "dismissed_tag_suggestions", Label: "DismissedTagSuggestions", Type: "[]string", InputKey: "dismissed_tag_suggestions", Clearable: true},
	DueDate:                         FieldDescriptor{Name: "due_date", Label: "DueDate", Type: "time.Time", InputKey: "due_date", Clearable: true},
	ExternalContents:                FieldDescriptor{Name: "external_contents", Label: "ExternalContents", Type: "string", MatchKey: true, InputKey: "external_contents", Clearable: true},
	ExternalFileID:                  FieldDescriptor{Name: "external_file_id", Label: "ExternalFileID", Type: "string", MatchKey: true, InputKey: "external_file_id", LookupKey: true, Clearable: true},
	ImprovementSuggestions:          FieldDescriptor{Name: "improvement_suggestions", Label: "ImprovementSuggestions", Type: "[]string", InputKey: "improvement_suggestions", Clearable: true},
	InternalNotes:                   FieldDescriptor{Name: "internal_notes", Label: "InternalNotes", Type: "string", MatchKey: true, InputKey: "internal_notes", Clearable: true},
	ManagementMode:                  FieldDescriptor{Name: "management_mode", Label: "ManagementMode", Type: "enums.DocumentManagementMode", InputKey: "management_mode", Clearable: true},
	Metadata:                        FieldDescriptor{Name: "metadata", Label: "Metadata", Type: "map[string]interface {}", InputKey: "metadata", Clearable: true, Volatile: true},
	Name:                            FieldDescriptor{Name: "name", Label: "Name", Type: "string", MatchKey: true, InputKey: "name", DisplayKey: true},
	Priority:                        FieldDescriptor{Name: "priority", Label: "Priority", Type: "enums.Priority", InputKey: "priority", Clearable: true},
	RawPayload:                      FieldDescriptor{Name: "raw_payload", Label: "RawPayload", Type: "map[string]interface {}", InputKey: "raw_payload", Clearable: true, Volatile: true},
	RequiresApproval:                FieldDescriptor{Name: "requires_approval", Label: "RequiresApproval", Type: "bool", InputKey: "requires_approval"},
	ReviewDue:                       FieldDescriptor{Name: "review_due", Label: "ReviewDue", Type: "time.Time", InputKey: "review_due", Clearable: true},
	ReviewFrequency:                 FieldDescriptor{Name: "review_frequency", Label: "ReviewFrequency", Type: "enums.Frequency", InputKey: "review_frequency", Clearable: true},
	Revision:                        FieldDescriptor{Name: "revision", Label: "Revision", Type: "string", MatchKey: true, InputKey: "revision", Clearable: true},
	Source:                          FieldDescriptor{Name: "source", Label: "Source", Type: "string", MatchKey: true, InputKey: "source", Clearable: true},
	Status:                          FieldDescriptor{Name: "status", Label: "Status", Type: "enums.DocumentStatus", WorkflowEligible: true, InputKey: "status", Clearable: true},
	SystemInternalID:                FieldDescriptor{Name: "system_internal_id", Label: "SystemInternalID", Type: "string", MatchKey: true, InputKey: "system_internal_id", Clearable: true},
	TagSuggestions:                  FieldDescriptor{Name: "tag_suggestions", Label: "TagSuggestions", Type: "[]string", InputKey: "tag_suggestions", Clearable: true},
	Tags:                            FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
	Title:                           FieldDescriptor{Name: "title", Label: "Title", Type: "string", MatchKey: true, InputKey: "title"},
	URL:                             FieldDescriptor{Name: "url", Label: "URL", Type: "string", MatchKey: true, InputKey: "url", Clearable: true},
}

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", Label: "AccessModelID", Type: "string", MatchKey: true, InputKey: "access_model_id", Clearable: true},
	AccessModelName:               FieldDescriptor{Name: "access_model_name", Label: "AccessModelName", Type: "string", MatchKey: true, InputKey: "access_model_name", Clearable: true, CaseInsensitive: true},
	AssetDataClassificationID:     FieldDescriptor{Name: "asset_data_classification_id", Label: "AssetDataClassificationID", Type: "string", MatchKey: true, InputKey: "asset_data_classification_id", Clearable: true},
	AssetDataClassificationName:   FieldDescriptor{Name: "asset_data_classification_name", Label: "AssetDataClassificationName", Type: "string", MatchKey: true, InputKey: "asset_data_classification_name", Clearable: true, CaseInsensitive: true},
	AssetSubtypeID:                FieldDescriptor{Name: "asset_subtype_id", Label: "AssetSubtypeID", Type: "string", MatchKey: true, InputKey: "asset_subtype_id", Clearable: true},
	AssetSubtypeName:              FieldDescriptor{Name: "asset_subtype_name", Label: "AssetSubtypeName", Type: "string", MatchKey: true, InputKey: "asset_subtype_name", Clearable: true, CaseInsensitive: true},
	AssetType:                     FieldDescriptor{Name: "asset_type", Label: "AssetType", Type: "enums.AssetType", InputKey: "asset_type"},
	Categories:                    FieldDescriptor{Name: "categories", Label: "Categories", Type: "[]string", InputKey: "categories", Clearable: true},
	ContainsPii:                   FieldDescriptor{Name: "contains_pii", Label: "ContainsPii", Type: "bool", InputKey: "contains_pii", Clearable: true},
	CostCenter:                    FieldDescriptor{Name: "cost_center", Label: "CostCenter", Type: "string", MatchKey: true, InputKey: "cost_center", Clearable: true},
	CriticalityID:                 FieldDescriptor{Name: "criticality_id", Label: "CriticalityID", Type: "string", MatchKey: true, InputKey: "criticality_id", Clearable: true},
	CriticalityName:               FieldDescriptor{Name: "criticality_name", Label: "CriticalityName", Type: "string", MatchKey: true, InputKey: "criticality_name", Clearable: true, CaseInsensitive: true},
	Description:                   FieldDescriptor{Name: "description", Label: "Description", Type: "string", MatchKey: true, InputKey: "description", Clearable: true},
	DisplayName:                   FieldDescriptor{Name: "display_name", Label: "DisplayName", Type: "string", MatchKey: true, InputKey: "display_name", Clearable: true},
	EncryptionStatusID:            FieldDescriptor{Name: "encryption_status_id", Label: "EncryptionStatusID", Type: "string", MatchKey: true, InputKey: "encryption_status_id", Clearable: true},
	EncryptionStatusName:          FieldDescriptor{Name: "encryption_status_name", Label: "EncryptionStatusName", Type: "string", MatchKey: true, InputKey: "encryption_status_name", Clearable: true, CaseInsensitive: true},
	EnvironmentID:                 FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:               FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	EstimatedMonthlyCost:          FieldDescriptor{Name: "estimated_monthly_cost", Label: "EstimatedMonthlyCost", Type: "float64", InputKey: "estimated_monthly_cost", Clearable: true},
	Identifier:                    FieldDescriptor{Name: "identifier", Label: "Identifier", Type: "string", MatchKey: true, InputKey: "identifier", Clearable: true},
	InternalNotes:                 FieldDescriptor{Name: "internal_notes", Label: "InternalNotes", Type: "string", MatchKey: true, InputKey: "internal_notes", Clearable: true},
	InternalOwner:                 FieldDescriptor{Name: "internal_owner", Label: "InternalOwner", Type: "string", MatchKey: true, InputKey: "internal_owner", Clearable: true},
	InternalOwnerGroupID:          FieldDescriptor{Name: "internal_owner_group_id", Label: "InternalOwnerGroupID", Type: "string", MatchKey: true, InputKey: "internal_owner_group_id", Clearable: true},
	InternalOwnerIdentityHolderID: FieldDescriptor{Name: "internal_owner_identity_holder_id", Label: "InternalOwnerIdentityHolderID", Type: "string", MatchKey: true, InputKey: "internal_owner_identity_holder_id", Clearable: true},
	InternalOwnerUserID:           FieldDescriptor{Name: "internal_owner_user_id", Label: "InternalOwnerUserID", Type: "string", MatchKey: true, InputKey: "internal_owner_user_id", Clearable: true},
	Name:                          FieldDescriptor{Name: "name", Label: "Name", Type: "string", MatchKey: true, InputKey: "name"},
	ObservedAt:                    FieldDescriptor{Name: "observed_at", Label: "ObservedAt", Type: "models.DateTime", InputKey: "observed_at", Clearable: true, Volatile: true},
	PhysicalLocation:              FieldDescriptor{Name: "physical_location", Label: "PhysicalLocation", Type: "string", MatchKey: true, InputKey: "physical_location", Clearable: true},
	PurchaseDate:                  FieldDescriptor{Name: "purchase_date", Label: "PurchaseDate", Type: "models.DateTime", InputKey: "purchase_date", Clearable: true},
	Region:                        FieldDescriptor{Name: "region", Label: "Region", Type: "string", MatchKey: true, InputKey: "region", Clearable: true},
	ScopeID:                       FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:                     FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	SecurityTierID:                FieldDescriptor{Name: "security_tier_id", Label: "SecurityTierID", Type: "string", MatchKey: true, InputKey: "security_tier_id", Clearable: true},
	SecurityTierName:              FieldDescriptor{Name: "security_tier_name", Label: "SecurityTierName", Type: "string", MatchKey: true, InputKey: "security_tier_name", Clearable: true, CaseInsensitive: true},
	SourceIdentifier:              FieldDescriptor{Name: "source_identifier", Label: "SourceIdentifier", Type: "string", MatchKey: true, InputKey: "source_identifier", LookupKey: true, Clearable: true},
	SourceType:                    FieldDescriptor{Name: "source_type", Label: "SourceType", Type: "enums.SourceType", InputKey: "source_type"},
	SystemInternalID:              FieldDescriptor{Name: "system_internal_id", Label: "SystemInternalID", Type: "string", MatchKey: true, InputKey: "system_internal_id", Clearable: true},
	Tags:                          FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
	Website:                       FieldDescriptor{Name: "website", Label: "Website", Type: "string", MatchKey: true, InputKey: "website", Clearable: true},
}

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", Label: "Details", Type: "string", MatchKey: true, InputKey: "details", Clearable: true},
	ExternalURI:      FieldDescriptor{Name: "external_uri", Label: "ExternalURI", Type: "string", MatchKey: true, InputKey: "external_uri", Clearable: true},
	LastObservedAt:   FieldDescriptor{Name: "last_observed_at", Label: "LastObservedAt", Type: "models.DateTime", InputKey: "last_observed_at", Clearable: true, Volatile: true},
	ParentExternalID: FieldDescriptor{Name: "parent_external_id", Label: "ParentExternalID", Type: "string", MatchKey: true, InputKey: "parent_external_id", LookupKey: true, Clearable: true},
	Source:           FieldDescriptor{Name: "source", Label: "Source", Type: "string", MatchKey: true, InputKey: "source"},
	Status:           FieldDescriptor{Name: "status", Label: "Status", Type: "enums.CheckStatus", InputKey: "status"},
	Tags:             FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
}

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", Label: "Address", Type: "string", MatchKey: true, InputKey: "address", Clearable: true},
	Company:     FieldDescriptor{Name: "company", Label: "Company", Type: "string", MatchKey: true, InputKey: "company", Clearable: true},
	Email:       FieldDescriptor{Name: "email", Label: "Email", Type: "string", MatchKey: true, InputKey: "email", Clearable: true},
	ExternalID:  FieldDescriptor{Name: "external_id", Label: "ExternalID", Type: "string", MatchKey: true, InputKey: "external_id", Clearable: true},
	FullName:    FieldDescriptor{Name: "full_name", Label: "FullName", Type: "string", MatchKey: true, InputKey: "full_name", Clearable: true},
	ObservedAt:  FieldDescriptor{Name: "observed_at", Label: "ObservedAt", Type: "models.DateTime", InputKey: "observed_at", Clearable: true, Volatile: true},
	PhoneNumber: FieldDescriptor{Name: "phone_number", Label: "PhoneNumber", Type: "string", MatchKey: true, InputKey: "phone_number", Clearable: true},
	Status:      FieldDescriptor{Name: "status", Label: "Status", Type: "enums.UserStatus", InputKey: "status"},
	Tags:        FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
	Title:       FieldDescriptor{Name: "title", Label: "Title", Type: "string", MatchKey: true, InputKey: "title", Clearable: true},
}

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", Label: "AccountType", Type: "enums.DirectoryAccountType", InputKey: "account_type", Clearable: true},
	AddedAt:          FieldDescriptor{Name: "added_at", Label: "AddedAt", Type: "time.Time", InputKey: "added_at", Clearable: true},
	AvatarRemoteURL:  FieldDescriptor{Name: "avatar_remote_url", Label: "AvatarRemoteURL", Type: "string", MatchKey: true, InputKey: "avatar_remote_url", Clearable: true},
	AvatarUpdatedAt:  FieldDescriptor{Name: "avatar_updated_at", Label: "AvatarUpdatedAt", Type: "time.Time", InputKey: "avatar_updated_at", Clearable: true},
	CanonicalEmail:   FieldDescriptor{Name: "canonical_email", Label: "CanonicalEmail", Type: "string", MatchKey: true, InputKey: "canonical_email", Clearable: true},
	Department:       FieldDescriptor{Name: "department", Label: "Department", Type: "string", MatchKey: true, InputKey: "department", Clearable: true},
	DirectoryName:    FieldDescriptor{Name: "directory_name", Label: "DirectoryName", Type: "string", MatchKey: true, InputKey: "directory_name", Clearable: true},
	DisplayName:      FieldDescriptor{Name: "display_name", Label: "DisplayName", Type: "string", MatchKey: true, InputKey: "display_name", Clearable: true},
	EmailAliases:     FieldDescriptor{Name: "email_aliases", Label: "EmailAliases", Type: "[]string", InputKey: "email_aliases", Clearable: true},
	EnvironmentID:    FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:  FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	ExternalID:       FieldDescriptor{Name: "external_id", Label: "ExternalID", Type: "string", MatchKey: true, InputKey: "external_id", LookupKey: true},
	FamilyName:       FieldDescriptor{Name: "family_name", Label: "FamilyName", Type: "string", MatchKey: true, InputKey: "family_name", Clearable: true},
	GivenName:        FieldDescriptor{Name: "given_name", Label: "GivenName", Type: "string", MatchKey: true, InputKey: "given_name", Clearable: true},
	IdentityHolderID: FieldDescriptor{Name: "identity_holder_id", Label: "IdentityHolderID", Type: "string", MatchKey: true, InputKey: "identity_holder_id", Clearable: true},
	JobTitle:         FieldDescriptor{Name: "job_title", Label: "JobTitle", Type: "string", MatchKey: true, InputKey: "job_title", Clearable: true},
	LastSeenIP:       FieldDescriptor{Name: "last_seen_ip", Label: "LastSeenIP", Type: "string", MatchKey: true, InputKey: "last_seen_ip", Clearable: true},
	Metadata:         FieldDescriptor{Name: "metadata", Label: "Metadata", Type: "map[string]interface {}", InputKey: "metadata", Clearable: true, Volatile: true},
	MfaState:         FieldDescriptor{Name: "mfa_state", Label: "MfaState", Type: "enums.DirectoryAccountMFAState", InputKey: "mfa_state"},
	ObservedAt:       FieldDescriptor{Name: "observed_at", Label: "ObservedAt", Type: "time.Time", InputKey: "observed_at"},
	OrganizationUnit: FieldDescriptor{Name: "organization_unit", Label: "OrganizationUnit", Type: "string", MatchKey: true, InputKey: "organization_unit", Clearable: true},
	PhoneNumber:      FieldDescriptor{Name: "phone_number", Label: "PhoneNumber", Type: "string", MatchKey: true, InputKey: "phone_number", Clearable: true},
	PrimarySource:    FieldDescriptor{Name: "primary_source", Label: "PrimarySource", Type: "bool", InputKey: "primary_source"},
	Profile:          FieldDescriptor{Name: "profile", Label: "Profile", Type: "map[string]interface {}", InputKey: "profile", Clearable: true, Volatile: true},
	RemovedAt:        FieldDescriptor{Name: "removed_at", Label: "RemovedAt", Type: "time.Time", InputKey: "removed_at", Clearable: true},
	ScopeID:          FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:        FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	SecondaryKey:     FieldDescriptor{Name: "secondary_key", Label: "SecondaryKey", Type: "string", MatchKey: true, InputKey: "secondary_key", Clearable: true},
	SourceVersion:    FieldDescriptor{Name: "source_version", Label: "SourceVersion", Type: "string", MatchKey: true, InputKey: "source_version", Clearable: true},
	Status:           FieldDescriptor{Name: "status", Label: "Status", Type: "enums.DirectoryAccountStatus", InputKey: "status"},
	Tags:             FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
}

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", Label: "AddedAt", Type: "time.Time", InputKey: "added_at", Clearable: true},
	Classification:         FieldDescriptor{Name: "classification", Label: "Classification", Type: "enums.DirectoryGroupClassification", InputKey: "classification"},
	DirectoryName:          FieldDescriptor{Name: "directory_name", Label: "DirectoryName", Type: "string", MatchKey: true, InputKey: "directory_name", Clearable: true},
	DisplayName:            FieldDescriptor{Name: "display_name", Label: "DisplayName", Type: "string", MatchKey: true, InputKey: "display_name", Clearable: true},
	Email:                  FieldDescriptor{Name: "email", Label: "Email", Type: "string", MatchKey: true, InputKey: "email", Clearable: true},
	EnvironmentID:          FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:        FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	ExternalID:             FieldDescriptor{Name: "external_id", Label: "ExternalID", Type: "string", MatchKey: true, InputKey: "external_id", LookupKey: true},
	ExternalSharingAllowed: FieldDescriptor{Name: "external_sharing_allowed", Label: "ExternalSharingAllowed", Type: "bool", InputKey: "external_sharing_allowed", Clearable: true},
	MemberCount:            FieldDescriptor{Name: "member_count", Label: "MemberCount", Type: "int", InputKey: "member_count", Clearable: true},
	Metadata:               FieldDescriptor{Name: "metadata", Label: "Metadata", Type: "map[string]interface {}", InputKey: "metadata", Clearable: true, Volatile: true},
	ObservedAt:             FieldDescriptor{Name: "observed_at", Label: "ObservedAt", Type: "time.Time", InputKey: "observed_at"},
	Profile:                FieldDescriptor{Name: "profile", Label: "Profile", Type: "map[string]interface {}", InputKey: "profile", Clearable: true, Volatile: true},
	RemovedAt:              FieldDescriptor{Name: "removed_at", Label: "RemovedAt", Type: "time.Time", InputKey: "removed_at", Clearable: true},
	ScopeID:                FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:              FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	SourceVersion:          FieldDescriptor{Name: "source_version", Label: "SourceVersion", Type: "string", MatchKey: true, InputKey: "source_version", Clearable: true, Volatile: true},
	Status:                 FieldDescriptor{Name: "status", Label: "Status", Type: "enums.DirectoryGroupStatus", InputKey: "status"},
	Tags:                   FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
}

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", Label: "AddedAt", Type: "time.Time", InputKey: "added_at", Clearable: true},
	DirectoryAccountID: FieldDescriptor{Name: "directory_account_id", Label: "DirectoryAccountID", Type: "string", MatchKey: true, InputKey: "directory_account_id", LookupKey: true},
	DirectoryGroupID:   FieldDescriptor{Name: "directory_group_id", Label: "DirectoryGroupID", Type: "string", MatchKey: true, InputKey: "directory_group_id", LookupKey: true},
	DirectoryName:      FieldDescriptor{Name: "directory_name", Label: "DirectoryName", Type: "string", MatchKey: true, InputKey: "directory_name", Clearable: true},
	EnvironmentID:      FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:    FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	Metadata:           FieldDescriptor{Name: "metadata", Label: "Metadata", Type: "map[string]interface {}", InputKey: "metadata", Clearable: true, Volatile: true},
	ObservedAt:         FieldDescriptor{Name: "observed_at", Label: "ObservedAt", Type: "time.Time", InputKey: "observed_at"},
	PlatformID:         FieldDescriptor{Name: "platform_id", Label: "PlatformID", Type: "string", MatchKey: true, InputKey: "platform_id", Clearable: true},
	RemovedAt:          FieldDescriptor{Name: "removed_at", Label: "RemovedAt", Type: "time.Time", InputKey: "removed_at", Clearable: true},
	Role:               FieldDescriptor{Name: "role", Label: "Role", Type: "enums.DirectoryMembershipRole", InputKey: "role", Clearable: true},
	ScopeID:            FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:          FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	Source:             FieldDescriptor{Name: "source", Label: "Source", Type: "string", MatchKey: true, InputKey: "source", Clearable: true},
}

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", Label: "Aliases", Type: "[]string", InputKey: "aliases", Clearable: true},
	AnnualSpend:                           FieldDescriptor{Name: "annual_spend", Label: "AnnualSpend", Type: "float64", InputKey: "annual_spend", Clearable: true},
	ApprovedForUse:                        FieldDescriptor{Name: "approved_for_use", Label: "ApprovedForUse", Type: "bool", InputKey: "approved_for_use", Clearable: true},
	AutoRenews:                            FieldDescriptor{Name: "auto_renews", Label: "AutoRenews", Type: "bool", InputKey: "auto_renews", Clearable: true},
	BillingModel:                          FieldDescriptor{Name: "billing_model", Label: "BillingModel", Type: "string", MatchKey: true, InputKey: "billing_model", Clearable: true},
	ContractEndDate:                       FieldDescriptor{Name: "contract_end_date", Label: "ContractEndDate", Type: "models.DateTime", InputKey: "contract_end_date", Clearable: true},
	ContractRenewalAt:                     FieldDescriptor{Name: "contract_renewal_at", Label: "ContractRenewalAt", Type: "models.DateTime", InputKey: "contract_renewal_at", Clearable: true},
	ContractStartDate:                     FieldDescriptor{Name: "contract_start_date", Label: "ContractStartDate", Type: "models.DateTime", InputKey: "contract_start_date", Clearable: true},
	Description:                           FieldDescriptor{Name: "description", Label: "Description", Type: "string", MatchKey: true, InputKey: "description", Clearable: true},
	DisplayName:                           FieldDescriptor{Name: "display_name", Label: "DisplayName", Type: "string", MatchKey: true, InputKey: "display_name", Clearable: true},
	Domains:                               FieldDescriptor{Name: "domains", Label: "Domains", Type: "[]string", InputKey: "domains", Clearable: true},
	EntityRelationshipStateID:             FieldDescriptor{Name: "entity_relationship_state_id", Label: "EntityRelationshipStateID", Type: "string", MatchKey: true, InputKey: "entity_relationship_state_id", Clearable: true},
	EntityRelationshipStateName:           FieldDescriptor{Name: "entity_relationship_state_name", Label: "EntityRelationshipStateName", Type: "string", MatchKey: true, InputKey: "entity_relationship_state_name", Clearable: true, CaseInsensitive: true},
	EntitySecurityQuestionnaireStatusID:   FieldDescriptor{Name: "entity_security_questionnaire_status_id", Label: "EntitySecurityQuestionnaireStatusID", Type: "string", MatchKey: true, InputKey: "entity_security_questionnaire_status_id", Clearable: true},
	EntitySecurityQuestionnaireStatusName: FieldDescriptor{Name: "entity_security_questionnaire_status_name", Label: "EntitySecurityQuestionnaireStatusName", Type: "string", MatchKey: true, InputKey: "entity_security_questionnaire_status_name", Clearable: true, CaseInsensitive: true},
	EntitySourceTypeID:                    FieldDescriptor{Name: "entity_source_type_id", Label: "EntitySourceTypeID", Type: "string", MatchKey: true, InputKey: "entity_source_type_id", Clearable: true},
	EntitySourceTypeName:                  FieldDescriptor{Name: "entity_source_type_name", Label: "EntitySourceTypeName", Type: "string", MatchKey: true, InputKey: "entity_source_type_name", Clearable: true, CaseInsensitive: true},
	EnvironmentID:                         FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:                       FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	ExternalID:                            FieldDescriptor{Name: "external_id", Label: "ExternalID", Type: "string", MatchKey: true, InputKey: "external_id", LookupKey: true, Clearable: true},
	HasSoc2:                               FieldDescriptor{Name: "has_soc2", Label: "HasSoc2", Type: "bool", InputKey: "has_soc2", Clearable: true},
	InternalNotes:                         FieldDescriptor{Name: "internal_notes", Label: "InternalNotes", Type: "string", MatchKey: true, InputKey: "internal_notes", Clearable: true},
	InternalOwner:                         FieldDescriptor{Name: "internal_owner", Label: "InternalOwner", Type: "string", MatchKey: true, InputKey: "internal_owner", Clearable: true},
	InternalOwnerGroupID:                  FieldDescriptor{Name: "internal_owner_group_id", Label: "InternalOwnerGroupID", Type: "string", MatchKey: true, InputKey: "internal_owner_group_id", Clearable: true},
	InternalOwnerIdentityHolderID:         FieldDescriptor{Name: "internal_owner_identity_holder_id", Label: "InternalOwnerIdentityHolderID", Type: "string", MatchKey: true, InputKey: "internal_owner_identity_holder_id", Clearable: true},
	InternalOwnerUserID:                   FieldDescriptor{Name: "internal_owner_user_id", Label: "InternalOwnerUserID", Type: "string", MatchKey: true, InputKey: "internal_owner_user_id", Clearable: true},
	LastReviewedAt:                        FieldDescriptor{Name: "last_reviewed_at", Label: "LastReviewedAt", Type: "models.DateTime", InputKey: "last_reviewed_at", Clearable: true},
	Links:                                 FieldDescriptor{Name: "links", Label: "Links", Type: "[]string", InputKey: "links", Clearable: true},
	LogoRemoteURL:                         FieldDescriptor{Name: "logo_remote_url", Label: "LogoRemoteURL", Type: "string", MatchKey: true, InputKey: "logo_remote_url", Clearable: true},
	MfaEnforced:                           FieldDescriptor{Name: "mfa_enforced", Label: "MfaEnforced", Type: "bool", InputKey: "mfa_enforced", Clearable: true},
	MfaSupported:                          FieldDescriptor{Name: "mfa_supported", Label: "MfaSupported", Type: "bool", InputKey: "mfa_supported", Clearable: true},
	Name:                                  FieldDescriptor{Name: "name", Label: "Name", Type: "string", MatchKey: true, InputKey: "name", Clearable: true},
	NextReviewAt:                          FieldDescriptor{Name: "next_review_at", Label: "NextReviewAt", Type: "models.DateTime", InputKey: "next_review_at", Clearable: true},
	ObservedAt:                            FieldDescriptor{Name: "observed_at", Label: "ObservedAt", Type: "models.DateTime", InputKey: "observed_at", Clearable: true},
	ProvidedServices:                      FieldDescriptor{Name: "provided_services", Label: "ProvidedServices", Type: "[]string", InputKey: "provided_services", Clearable: true},
	RenewalRisk:                           FieldDescriptor{Name: "renewal_risk", Label: "RenewalRisk", Type: "string", MatchKey: true, InputKey: "renewal_risk", Clearable: true},
	ReviewFrequency:                       FieldDescriptor{Name: "review_frequency", Label: "ReviewFrequency", Type: "enums.Frequency", InputKey: "review_frequency", Clearable: true},
	ReviewedBy:                            FieldDescriptor{Name: "reviewed_by", Label: "ReviewedBy", Type: "string", MatchKey: true, InputKey: "reviewed_by", Clearable: true},
	ReviewedByGroupID:                     FieldDescriptor{Name: "reviewed_by_group_id", Label: "ReviewedByGroupID", Type: "string", MatchKey: true, InputKey: "reviewed_by_group_id", Clearable: true},
	ReviewedByIdentityHolderID:            FieldDescriptor{Name: "reviewed_by_identity_holder_id", Label: "ReviewedByIdentityHolderID", Type: "string", MatchKey: true, InputKey: "reviewed_by_identity_holder_id", Clearable: true},
	ReviewedByUserID:                      FieldDescriptor{Name: "reviewed_by_user_id", Label: "ReviewedByUserID", Type: "string", MatchKey: true, InputKey: "reviewed_by_user_id", Clearable: true},
	RiskRating:                            FieldDescriptor{Name: "risk_rating", Label: "RiskRating", Type: "string", MatchKey: true, InputKey: "risk_rating", Clearable: true},
	RiskScore:                             FieldDescriptor{Name: "risk_score", Label: "RiskScore", Type: "int", InputKey: "risk_score", Clearable: true},
	ScopeID:                               FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:                             FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	Soc2PeriodEnd:                         FieldDescriptor{Name: "soc2_period_end", Label: "Soc2PeriodEnd", Type: "models.DateTime", InputKey: "soc2_period_end", Clearable: true},
	SpendCurrency:                         FieldDescriptor{Name: "spend_currency", Label: "SpendCurrency", Type: "string", MatchKey: true, InputKey: "spend_currency", Clearable: true},
	SSOEnforced:                           FieldDescriptor{Name: "sso_enforced", Label: "SSOEnforced", Type: "bool", InputKey: "sso_enforced", Clearable: true},
	Status:                                FieldDescriptor{Name: "status", Label: "Status", Type: "enums.EntityStatus", InputKey: "status", Clearable: true},
	StatusPageURL:                         FieldDescriptor{Name: "status_page_url", Label: "StatusPageURL", Type: "string", MatchKey: true, InputKey: "status_page_url", Clearable: true},
	SystemInternalID:                      FieldDescriptor{Name: "system_internal_id", Label: "SystemInternalID", Type: "string", MatchKey: true, InputKey: "system_internal_id", Clearable: true},
	Tags:                                  FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
	TerminationNoticeDays:                 FieldDescriptor{Name: "termination_notice_days", Label: "TerminationNoticeDays", Type: "int", InputKey: "termination_notice_days", Clearable: true},
	Tier:                                  FieldDescriptor{Name: "tier", Label: "Tier", Type: "enums.VendorTier", InputKey: "tier", Clearable: true},
	VendorMetadata:                        FieldDescriptor{Name: "vendor_metadata", Label: "VendorMetadata", Type: "map[string]interface {}", InputKey: "vendor_metadata", Clearable: true, Volatile: true},
}

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", Label: "AssessmentID", Type: "string", MatchKey: true, InputKey: "assessment_id", Clearable: true},
	AssignedTo:                    FieldDescriptor{Name: "assigned_to", Label: "AssignedTo", Type: "string", MatchKey: true, InputKey: "assigned_to", Clearable: true},
	AssignedToGroupID:             FieldDescriptor{Name: "assigned_to_group_id", Label: "AssignedToGroupID", Type: "string", MatchKey: true, InputKey: "assigned_to_group_id", Clearable: true},
	AssignedToIdentityHolderID:    FieldDescriptor{Name: "assigned_to_identity_holder_id", Label: "AssignedToIdentityHolderID", Type: "string", MatchKey: true, InputKey: "assigned_to_identity_holder_id", Clearable: true},
	AssignedToUserID:              FieldDescriptor{Name: "assigned_to_user_id", Label: "AssignedToUserID", Type: "string", MatchKey: true, InputKey: "assigned_to_user_id", Clearable: true},
	BlocksProduction:              FieldDescriptor{Name: "blocks_production", Label: "BlocksProduction", Type: "bool", WorkflowEligible: true, InputKey: "blocks_production", Clearable: true},
	Categories:                    FieldDescriptor{Name: "categories", Label: "Categories", Type: "[]string", InputKey: "categories", Clearable: true},
	Category:                      FieldDescriptor{Name: "category", Label: "Category", Type: "string", WorkflowEligible: true, MatchKey: true, InputKey: "category", Clearable: true},
	Description:                   FieldDescriptor{Name: "description", Label: "Description", Type: "string", MatchKey: true, InputKey: "description", Clearable: true},
	DisplayName:                   FieldDescriptor{Name: "display_name", Label: "DisplayName", Type: "string", MatchKey: true, InputKey: "display_name", Clearable: true},
	EnvironmentID:                 FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:               FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	EventTime:                     FieldDescriptor{Name: "event_time", Label: "EventTime", Type: "models.DateTime", WorkflowEligible: true, InputKey: "event_time", Clearable: true, Volatile: true},
	Exploitability:                FieldDescriptor{Name: "exploitability", Label: "Exploitability", Type: "float64", InputKey: "exploitability", Clearable: true},
	ExternalID:                    FieldDescriptor{Name: "external_id", Label: "ExternalID", Type: "string", MatchKey: true, InputKey: "external_id", LookupKey: true, Clearable: true},
	ExternalOwnerID:               FieldDescriptor{Name: "external_owner_id", Label: "ExternalOwnerID", Type: "string", MatchKey: true, InputKey: "external_owner_id", Clearable: true},
	ExternalURI:                   FieldDescriptor{Name: "external_uri", Label: "ExternalURI", Type: "string", MatchKey: true, InputKey: "external_uri", Clearable: true},
	FindingClass:                  FieldDescriptor{Name: "finding_class", Label: "FindingClass", Type: "string", MatchKey: true, InputKey: "finding_class", Clearable: true},
	FindingStatusID:               FieldDescriptor{Name: "finding_status_id", Label: "FindingStatusID", Type: "string", MatchKey: true, InputKey: "finding_status_id", Clearable: true},
	FindingStatusName:             FieldDescriptor{Name: "finding_status_name", Label: "FindingStatusName", Type: "string", MatchKey: true, InputKey: "finding_status_name", Clearable: true, CaseInsensitive: true},
	Impact:                        FieldDescriptor{Name: "impact", Label: "Impact", Type: "float64", InputKey: "impact", Clearable: true},
	InternalNotes:                 FieldDescriptor{Name: "internal_notes", Label: "InternalNotes", Type: "string", MatchKey: true, InputKey: "internal_notes", Clearable: true},
	InternalOwner:                 FieldDescriptor{Name: "internal_owner", Label: "InternalOwner", Type: "string", MatchKey: true, InputKey: "internal_owner", Clearable: true},
	InternalOwnerGroupID:          FieldDescriptor{Name: "internal_owner_group_id", Label: "InternalOwnerGroupID", Type: "string", MatchKey: true, InputKey: "internal_owner_group_id", Clearable: true},
	InternalOwnerIdentityHolderID: FieldDescriptor{Name: "internal_owner_identity_holder_id", Label: "InternalOwnerIdentityHolderID", Type: "string", MatchKey: true, InputKey: "internal_owner_identity_holder_id", Clearable: true},
	InternalOwnerUserID:           FieldDescriptor{Name: "internal_owner_user_id", Label: "InternalOwnerUserID", Type: "string", MatchKey: true, InputKey: "internal_owner_user_id", Clearable: true},
	Metadata:                      FieldDescriptor{Name: "metadata", Label: "Metadata", Type: "map[string]interface {}", InputKey: "metadata", Clearable: true, Volatile: true},
	NumericSeverity:               FieldDescriptor{Name: "numeric_severity", Label: "NumericSeverity", Type: "float64", InputKey: "numeric_severity", Clearable: true},
	Open:                          FieldDescriptor{Name: "open", Label: "Open", Type: "bool", WorkflowEligible: true, InputKey: "open", Clearable: true},
	Priority:                      FieldDescriptor{Name: "priority", Label: "Priority", Type: "string", WorkflowEligible: true, MatchKey: true, InputKey: "priority", Clearable: true},
	Production:                    FieldDescriptor{Name: "production", Label: "Production", Type: "bool", WorkflowEligible: true, InputKey: "production", Clearable: true},
	Public:                        FieldDescriptor{Name: "public", Label: "Public", Type: "bool", WorkflowEligible: true, InputKey: "public", Clearable: true},
	RawPayload:                    FieldDescriptor{Name: "raw_payload", Label: "RawPayload", Type: "map[string]interface {}", InputKey: "raw_payload", Clearable: true, Volatile: true},
	Recommendation:                FieldDescriptor{Name: "recommendation", Label: "Recommendation", Type: "string", MatchKey: true, InputKey: "recommendation", Clearable: true},
	RecommendedActions:            FieldDescriptor{Name: "recommended_actions", Label: "RecommendedActions", Type: "string", MatchKey: true, InputKey: "recommended_actions", Clearable: true},
	References:                    FieldDescriptor{Name: "references", Label: "References", Type: "[]string", InputKey: "references", Clearable: true},
	RemediationSLA:                FieldDescriptor{Name: "remediation_sla", Label: "RemediationSLA", Type: "int", WorkflowEligible: true, InputKey: "remediation_sla", Clearable: true},
	ReportedAt:                    FieldDescriptor{Name: "reported_at", Label: "ReportedAt", Type: "models.DateTime", WorkflowEligible: true, InputKey: "reported_at", Clearable: true},
	ResourceName:                  FieldDescriptor{Name: "resource_name", Label: "ResourceName", Type: "string", MatchKey: true, InputKey: "resource_name", Clearable: true},
	ReviewedBy:                    FieldDescriptor{Name: "reviewed_by", Label: "ReviewedBy", Type: "string", MatchKey: true, InputKey: "reviewed_by", Clearable: true},
	ReviewedByGroupID:             FieldDescriptor{Name: "reviewed_by_group_id", Label: "ReviewedByGroupID", Type: "string", MatchKey: true, InputKey: "reviewed_by_group_id", Clearable: true},
	ReviewedByIdentityHolderID:    FieldDescriptor{Name: "reviewed_by_identity_holder_id", Label: "ReviewedByIdentityHolderID", Type: "string", MatchKey: true, InputKey: "reviewed_by_identity_holder_id", Clearable: true},
	ReviewedByUserID:              FieldDescriptor{Name: "reviewed_by_user_id", Label: "ReviewedByUserID", Type: "string", MatchKey: true, InputKey: "reviewed_by_user_id", Clearable: true},
	ScopeID:                       FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:                     FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	Score:                         FieldDescriptor{Name: "score", Label: "Score", Type: "float64", WorkflowEligible: true, InputKey: "score", Clearable: true},
	Severity:                      FieldDescriptor{Name: "severity", Label: "Severity", Type: "string", WorkflowEligible: true, MatchKey: true, InputKey: "severity", Clearable: true},
	Source:                        FieldDescriptor{Name: "source", Label: "Source", Type: "string", MatchKey: true, InputKey: "source", Clearable: true},
	SourceUpdatedAt:               FieldDescriptor{Name: "source_updated_at", Label: "SourceUpdatedAt", Type: "models.DateTime", InputKey: "source_updated_at", Clearable: true, Volatile: true},
	State:                         FieldDescriptor{Name: "state", Label: "State", Type: "string", WorkflowEligible: true, MatchKey: true, InputKey: "state", Clearable: true},
	StepsToReproduce:              FieldDescriptor{Name: "steps_to_reproduce", Label: "StepsToReproduce", Type: "[]string", InputKey: "steps_to_reproduce", Clearable: true},
	SystemInternalID:              FieldDescriptor{Name: "system_internal_id", Label: "SystemInternalID", Type: "string", MatchKey: true, InputKey: "system_internal_id", Clearable: true},
	Tags:                          FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
	TargetDetails:                 FieldDescriptor{Name: "target_details", Label: "TargetDetails", Type: "map[string]interface {}", InputKey: "target_details", Clearable: true},
	Targets:                       FieldDescriptor{Name: "targets", Label: "Targets", Type: "[]string", InputKey: "targets", Clearable: true},
	Validated:                     FieldDescriptor{Name: "validated", Label: "Validated", Type: "bool", WorkflowEligible: true, InputKey: "validated", Clearable: true},
	Vector:                        FieldDescriptor{Name: "vector", Label: "Vector", Type: "string", MatchKey: true, InputKey: "vector", Clearable: true},
}

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", Label: "ApprovalRequired", Type: "bool", InputKey: "approval_required", Clearable: true},
	ApproverID:                      FieldDescriptor{Name: "approver_id", Label: "ApproverID", Type: "string", MatchKey: true, InputKey: "approver_id", Clearable: true},
	ControlSuggestions:              FieldDescriptor{Name: "control_suggestions", Label: "ControlSuggestions", Type: "[]string", InputKey: "control_suggestions", Clearable: true},
	DelegateID:                      FieldDescriptor{Name: "delegate_id", Label: "DelegateID", Type: "string", MatchKey: true, InputKey: "delegate_id", Clearable: true},
	Details:                         FieldDescriptor{Name: "details", Label: "Details", Type: "string", WorkflowEligible: true, MatchKey: true, InputKey: "details", Clearable: true},
	DetailsJSON:                     FieldDescriptor{Name: "details_json", Label: "DetailsJSON", Type: "[]interface {}", WorkflowEligible: true, InputKey: "details_json", Clearable: true},
	DismissedControlSuggestions:     FieldDescriptor{Name: "dismissed_control_suggestions", Label: "DismissedControlSuggestions", Type: "[]string", InputKey: "dismissed_control_suggestions", Clearable: true},
	DismissedImprovementSuggestions: FieldDescriptor{Name: "dismissed_improvement_suggestions", Label: "DismissedImprovementSuggestions", Type: "[]string", InputKey: "dismissed_improvement_suggestions", Clearable: true},
	DismissedTagSuggestions:         FieldDescriptor{Name: "dismissed_tag_suggestions", Label: "DismissedTagSuggestions", Type: "[]string", InputKey: "dismissed_tag_suggestions", Clearable: true},
	EnvironmentID:                   FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:                 FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	ExternalContents:                FieldDescriptor{Name: "external_contents", Label: "ExternalContents", Type: "string", MatchKey: true, InputKey: "external_contents", Clearable: true},
	ExternalFileID:                  FieldDescriptor{Name: "external_file_id", Label: "ExternalFileID", Type: "string", MatchKey: true, InputKey: "external_file_id", LookupKey: true, Clearable: true},
	ExternalUUID:                    FieldDescriptor{Name: "external_uuid", Label: "ExternalUUID", Type: "string", MatchKey: true, InputKey: "external_uuid", Clearable: true},
	ImprovementSuggestions:          FieldDescriptor{Name: "improvement_suggestions", Label: "ImprovementSuggestions", Type: "[]string", InputKey: "improvement_suggestions", Clearable: true},
	InternalNotes:                   FieldDescriptor{Name: "internal_notes", Label: "InternalNotes", Type: "string", MatchKey: true, InputKey: "internal_notes", Clearable: true},
	InternalPolicyKindID:            FieldDescriptor{Name: "internal_policy_kind_id", Label: "InternalPolicyKindID", Type: "string", MatchKey: true, InputKey: "internal_policy_kind_id", Clearable: true},
	InternalPolicyKindName:          FieldDescriptor{Name: "internal_policy_kind_name", Label: "InternalPolicyKindName", Type: "string", MatchKey: true, InputKey: "internal_policy_kind_name", Clearable: true, CaseInsensitive: true},
	ManagementMode:                  FieldDescriptor{Name: "management_mode", Label: "ManagementMode", Type: "enums.DocumentManagementMode", InputKey: "management_mode", Clearable: true},
	Name:                            FieldDescriptor{Name: "name", Label: "Name", Type: "string", MatchKey: true, InputKey: "name", DisplayKey: true},
	ReviewDue:                       FieldDescriptor{Name: "review_due", Label: "ReviewDue", Type: "time.Time", InputKey: "review_due", Clearable: true},
	ReviewFrequency:                 FieldDescriptor{Name: "review_frequency", Label: "ReviewFrequency", Type: "enums.Frequency", InputKey: "review_frequency", Clearable: true},
	Revision:                        FieldDescriptor{Name: "revision", Label: "Revision", Type: "string", MatchKey: true, InputKey: "revision", Clearable: true},
	ScopeID:                         FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:                       FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	Status:                          FieldDescriptor{Name: "status", Label: "Status", Type: "enums.DocumentStatus", WorkflowEligible: true, InputKey: "status", Clearable: true},
	SystemInternalID:                FieldDescriptor{Name: "system_internal_id", Label: "SystemInternalID", Type: "string", MatchKey: true, InputKey: "system_internal_id", Clearable: true},
	TagSuggestions:                  FieldDescriptor{Name: "tag_suggestions", Label: "TagSuggestions", Type: "[]string", InputKey: "tag_suggestions", Clearable: true},
	Tags:                            FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
	URL:                             FieldDescriptor{Name: "url", Label: "URL", Type: "string", MatchKey: true, InputKey: "url", Clearable: true},
}

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", Label: "ApprovalRequired", Type: "bool", InputKey: "approval_required", Clearable: true},
	ApproverID:                      FieldDescriptor{Name: "approver_id", Label: "ApproverID", Type: "string", MatchKey: true, InputKey: "approver_id", Clearable: true},
	ControlSuggestions:              FieldDescriptor{Name: "control_suggestions", Label: "ControlSuggestions", Type: "[]string", InputKey: "control_suggestions", Clearable: true},
	DelegateID:                      FieldDescriptor{Name: "delegate_id", Label: "DelegateID", Type: "string", MatchKey: true, InputKey: "delegate_id", Clearable: true},
	Details:                         FieldDescriptor{Name: "details", Label: "Details", Type: "string", WorkflowEligible: true, MatchKey: true, InputKey: "details", Clearable: true},
	DetailsJSON:                     FieldDescriptor{Name: "details_json", Label: "DetailsJSON", Type: "[]interface {}", WorkflowEligible: true, InputKey: "details_json", Clearable: true},
	DismissedControlSuggestions:     FieldDescriptor{Name: "dismissed_control_suggestions", Label: "DismissedControlSuggestions", Type: "[]string", InputKey: "dismissed_control_suggestions", Clearable: true},
	DismissedImprovementSuggestions: FieldDescriptor{Name: "dismissed_improvement_suggestions", Label: "DismissedImprovementSuggestions", Type: "[]string", InputKey: "dismissed_improvement_suggestions", Clearable: true},
	DismissedTagSuggestions:         FieldDescriptor{Name: "dismissed_tag_suggestions", Label: "DismissedTagSuggestions", Type: "[]string", InputKey: "dismissed_tag_suggestions", Clearable: true},
	EnvironmentID:                   FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:                 FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	ExternalContents:                FieldDescriptor{Name: "external_contents", Label: "ExternalContents", Type: "string", MatchKey: true, InputKey: "external_contents", Clearable: true},
	ExternalFileID:                  FieldDescriptor{Name: "external_file_id", Label: "ExternalFileID", Type: "string", MatchKey: true, InputKey: "external_file_id", LookupKey: true, Clearable: true},
	ImprovementSuggestions:          FieldDescriptor{Name: "improvement_suggestions", Label: "ImprovementSuggestions", Type: "[]string", InputKey: "improvement_suggestions", Clearable: true},
	InternalNotes:                   FieldDescriptor{Name: "internal_notes", Label: "InternalNotes", Type: "string", MatchKey: true, InputKey: "internal_notes", Clearable: true},
	ManagementMode:                  FieldDescriptor{Name: "management_mode", Label: "ManagementMode", Type: "enums.DocumentManagementMode", InputKey: "management_mode", Clearable: true},
	Name:                            FieldDescriptor{Name: "name", Label: "Name", Type: "string", MatchKey: true, InputKey: "name", DisplayKey: true},
	ProcedureKindID:                 FieldDescriptor{Name: "procedure_kind_id", Label: "ProcedureKindID", Type: "string", MatchKey: true, InputKey: "procedure_kind_id", Clearable: true},
	ProcedureKindName:               FieldDescriptor{Name: "procedure_kind_name", Label: "ProcedureKindName", Type: "string", MatchKey: true, InputKey: "procedure_kind_name", Clearable: true, CaseInsensitive: true},
	ReviewDue:                       FieldDescriptor{Name: "review_due", Label: "ReviewDue", Type: "time.Time", InputKey: "review_due", Clearable: true},
	ReviewFrequency:                 FieldDescriptor{Name: "review_frequency", Label: "ReviewFrequency", Type: "enums.Frequency", InputKey: "review_frequency", Clearable: true},
	Revision:                        FieldDescriptor{Name: "revision", Label: "Revision", Type: "string", MatchKey: true, InputKey: "revision", Clearable: true},
	ScopeID:                         FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:                       FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	Status:                          FieldDescriptor{Name: "status", Label: "Status", Type: "enums.DocumentStatus", WorkflowEligible: true, InputKey: "status", Clearable: true},
	SystemInternalID:                FieldDescriptor{Name: "system_internal_id", Label: "SystemInternalID", Type: "string", MatchKey: true, InputKey: "system_internal_id", Clearable: true},
	TagSuggestions:                  FieldDescriptor{Name: "tag_suggestions", Label: "TagSuggestions", Type: "[]string", InputKey: "tag_suggestions", Clearable: true},
	Tags:                            FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
	URL:                             FieldDescriptor{Name: "url", Label: "URL", Type: "string", MatchKey: true, InputKey: "url", Clearable: true},
}

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", Label: "BusinessCosts", Type: "string", MatchKey: true, InputKey: "business_costs", Clearable: true},
	BusinessCostsJSON:           FieldDescriptor{Name: "business_costs_json", Label: "BusinessCostsJSON", Type: "[]interface {}", InputKey: "business_costs_json", Clearable: true},
	DelegateGroupID:             FieldDescriptor{Name: "delegate_group_id", Label: "DelegateGroupID", Type: "string", MatchKey: true, InputKey: "delegate_group_id", Clearable: true},
	DelegateIdentityHolderID:    FieldDescriptor{Name: "delegate_identity_holder_id", Label: "DelegateIdentityHolderID", Type: "string", MatchKey: true, InputKey: "delegate_identity_holder_id", Clearable: true},
	DelegateName:                FieldDescriptor{Name: "delegate_name", Label: "DelegateName", Type: "string", MatchKey: true, InputKey: "delegate_name", Clearable: true},
	DelegateUserID:              FieldDescriptor{Name: "delegate_user_id", Label: "DelegateUserID", Type: "string", MatchKey: true, InputKey: "delegate_user_id", Clearable: true},
	Details:                     FieldDescriptor{Name: "details", Label: "Details", Type: "string", MatchKey: true, InputKey: "details", Clearable: true},
	DetailsJSON:                 FieldDescriptor{Name: "details_json", Label: "DetailsJSON", Type: "[]interface {}", InputKey: "details_json", Clearable: true},
	DueDate:                     FieldDescriptor{Name: "due_date", Label: "DueDate", Type: "models.DateTime", WorkflowEligible: true, InputKey: "due_date", Clearable: true},
	EnvironmentID:               FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:             FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	ExternalID:                  FieldDescriptor{Name: "external_id", Label: "ExternalID", Type: "string", MatchKey: true, InputKey: "external_id", LookupKey: true, Clearable: true},
	ExternalUUID:                FieldDescriptor{Name: "external_uuid", Label: "ExternalUUID", Type: "string", MatchKey: true, InputKey: "external_uuid", Clearable: true},
	Impact:                      FieldDescriptor{Name: "impact", Label: "Impact", Type: "enums.RiskImpact", WorkflowEligible: true, InputKey: "impact", Clearable: true},
	LastReviewedAt:              FieldDescriptor{Name: "last_reviewed_at", Label: "LastReviewedAt", Type: "models.DateTime", WorkflowEligible: true, InputKey: "last_reviewed_at", Clearable: true},
	Likelihood:                  FieldDescriptor{Name: "likelihood", Label: "Likelihood", Type: "enums.RiskLikelihood", WorkflowEligible: true, InputKey: "likelihood", Clearable: true},
	MitigatedAt:                 FieldDescriptor{Name: "mitigated_at", Label: "MitigatedAt", Type: "models.DateTime", WorkflowEligible: true, InputKey: "mitigated_at", Clearable: true},
	Mitigation:                  FieldDescriptor{Name: "mitigation", Label: "Mitigation", Type: "string", MatchKey: true, InputKey: "mitigation", Clearable: true},
	MitigationJSON:              FieldDescriptor{Name: "mitigation_json", Label: "MitigationJSON", Type: "[]interface {}", InputKey: "mitigation_json", Clearable: true},
	Name:                        FieldDescriptor{Name: "name", Label: "Name", Type: "string", MatchKey: true, InputKey: "name", DisplayKey: true},
	NextReviewDueAt:             FieldDescriptor{Name: "next_review_due_at", Label: "NextReviewDueAt", Type: "models.DateTime", WorkflowEligible: true, InputKey: "next_review_due_at", Clearable: true},
	ObservedAt:                  FieldDescriptor{Name: "observed_at", Label: "ObservedAt", Type: "models.DateTime", InputKey: "observed_at", Clearable: true, Volatile: true},
	ResidualScore:               FieldDescriptor{Name: "residual_score", Label: "ResidualScore", Type: "int", WorkflowEligible: true, InputKey: "residual_score", Clearable: true},
	ReviewFrequency:             FieldDescriptor{Name: "review_frequency", Label: "ReviewFrequency", Type: "enums.Frequency", WorkflowEligible: true, InputKey: "review_frequency", Clearable: true},
	ReviewRequired:              FieldDescriptor{Name: "review_required", Label: "ReviewRequired", Type: "bool", WorkflowEligible: true, InputKey: "review_required", Clearable: true},
	RiskCategoryID:              FieldDescriptor{Name: "risk_category_id", Label: "RiskCategoryID", Type: "string", MatchKey: true, InputKey: "risk_category_id", Clearable: true},
	RiskCategoryName:            FieldDescriptor{Name: "risk_category_name", Label: "RiskCategoryName", Type: "string", MatchKey: true, InputKey: "risk_category_name", Clearable: true, CaseInsensitive: true},
	RiskDecision:                FieldDescriptor{Name: "risk_decision", Label: "RiskDecision", Type: "enums.RiskDecision", WorkflowEligible: true, InputKey: "risk_decision", Clearable: true},
	RiskKindID:                  FieldDescriptor{Name: "risk_kind_id", Label: "RiskKindID", Type: "string", MatchKey: true, InputKey: "risk_kind_id", Clearable: true},
	RiskKindName:                FieldDescriptor{Name: "risk_kind_name", Label: "RiskKindName", Type: "string", MatchKey: true, InputKey: "risk_kind_name", Clearable: true, CaseInsensitive: true},
	ScopeID:                     FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:                   FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	Score:                       FieldDescriptor{Name: "score", Label: "Score", Type: "int", WorkflowEligible: true, InputKey: "score", Clearable: true},
	StakeholderGroupID:          FieldDescriptor{Name: "stakeholder_group_id", Label: "StakeholderGroupID", Type: "string", MatchKey: true, InputKey: "stakeholder_group_id", Clearable: true},
	StakeholderIdentityHolderID: FieldDescriptor{Name: "stakeholder_identity_holder_id", Label: "StakeholderIdentityHolderID", Type: "string", MatchKey: true, InputKey: "stakeholder_identity_holder_id", Clearable: true},
	StakeholderName:             FieldDescriptor{Name: "stakeholder_name", Label: "StakeholderName", Type: "string", MatchKey: true, InputKey: "stakeholder_name", Clearable: true},
	StakeholderUserID:           FieldDescriptor{Name: "stakeholder_user_id", Label: "StakeholderUserID", Type: "string", MatchKey: true, InputKey: "stakeholder_user_id", Clearable: true},
	Status:                      FieldDescriptor{Name: "status", Label: "Status", Type: "enums.RiskStatus", WorkflowEligible: true, InputKey: "status", Clearable: true},
	Tags:                        FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
}

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", Label: "AssignedTo", Type: "string", MatchKey: true, InputKey: "assigned_to", Clearable: true},
	AssignedToGroupID:             FieldDescriptor{Name: "assigned_to_group_id", Label: "AssignedToGroupID", Type: "string", MatchKey: true, InputKey: "assigned_to_group_id", Clearable: true},
	AssignedToIdentityHolderID:    FieldDescriptor{Name: "assigned_to_identity_holder_id", Label: "AssignedToIdentityHolderID", Type: "string", MatchKey: true, InputKey: "assigned_to_identity_holder_id", Clearable: true},
	AssignedToUserID:              FieldDescriptor{Name: "assigned_to_user_id", Label: "AssignedToUserID", Type: "string", MatchKey: true, InputKey: "assigned_to_user_id", Clearable: true},
	AutoDismissedAt:               FieldDescriptor{Name: "auto_dismissed_at", Label: "AutoDismissedAt", Type: "models.DateTime", InputKey: "auto_dismissed_at", Clearable: true},
	Blocking:                      FieldDescriptor{Name: "blocking", Label: "Blocking", Type: "bool", WorkflowEligible: true, InputKey: "blocking", Clearable: true},
	Category:                      FieldDescriptor{Name: "category", Label: "Category", Type: "string", MatchKey: true, InputKey: "category", Clearable: true},
	CveID:                         FieldDescriptor{Name: "cve_id", Label: "CveID", Type: "string", MatchKey: true, InputKey: "cve_id", Clearable: true},
	CweIds:                        FieldDescriptor{Name: "cwe_ids", Label: "CweIds", Type: "[]string", InputKey: "cwe_ids", Clearable: true},
	DependencyScope:               FieldDescriptor{Name: "dependency_scope", Label: "DependencyScope", Type: "string", MatchKey: true, InputKey: "dependency_scope", Clearable: true},
	Description:                   FieldDescriptor{Name: "description", Label: "Description", Type: "string", MatchKey: true, InputKey: "description", Clearable: true},
	DiscoveredAt:                  FieldDescriptor{Name: "discovered_at", Label: "DiscoveredAt", Type: "models.DateTime", WorkflowEligible: true, InputKey: "discovered_at", Clearable: true},
	DismissedAt:                   FieldDescriptor{Name: "dismissed_at", Label: "DismissedAt", Type: "models.DateTime", WorkflowEligible: true, InputKey: "dismissed_at", Clearable: true},
	DismissedComment:              FieldDescriptor{Name: "dismissed_comment", Label: "DismissedComment", Type: "string", MatchKey: true, InputKey: "dismissed_comment", Clearable: true},
	DismissedReason:               FieldDescriptor{Name: "dismissed_reason", Label: "DismissedReason", Type: "string", MatchKey: true, InputKey: "dismissed_reason", Clearable: true},
	DisplayName:                   FieldDescriptor{Name: "display_name", Label: "DisplayName", Type: "string", MatchKey: true, InputKey: "display_name", Clearable: true},
	EnvironmentID:                 FieldDescriptor{Name: "environment_id", Label: "EnvironmentID", Type: "string", MatchKey: true, InputKey: "environment_id", Clearable: true},
	EnvironmentName:               FieldDescriptor{Name: "environment_name", Label: "EnvironmentName", Type: "string", MatchKey: true, InputKey: "environment_name", Clearable: true, CaseInsensitive: true},
	Exploitability:                FieldDescriptor{Name: "exploitability", Label: "Exploitability", Type: "float64", InputKey: "exploitability", Clearable: true},
	ExternalID:                    FieldDescriptor{Name: "external_id", Label: "ExternalID", Type: "string", MatchKey: true, InputKey: "external_id", LookupKey: true},
	ExternalOwnerID:               FieldDescriptor{Name: "external_owner_id", Label: "ExternalOwnerID", Type: "string", MatchKey: true, InputKey: "external_owner_id", Clearable: true},
	ExternalURI:                   FieldDescriptor{Name: "external_uri", Label: "ExternalURI", Type: "string", MatchKey: true, InputKey: "external_uri", Clearable: true},
	FirstPatchedVersion:           FieldDescriptor{Name: "first_patched_version", Label: "FirstPatchedVersion", Type: "string", MatchKey: true, InputKey: "first_patched_version", Clearable: true},
	FixAvailable:                  FieldDescriptor{Name: "fix_available", Label: "FixAvailable", Type: "bool", WorkflowEligible: true, InputKey: "fix_available", Clearable: true},
	FixedAt:                       FieldDescriptor{Name: "fixed_at", Label: "FixedAt", Type: "models.DateTime", WorkflowEligible: true, InputKey: "fixed_at", Clearable: true},
	Impact:                        FieldDescriptor{Name: "impact", Label: "Impact", Type: "float64", InputKey: "impact", Clearable: true},
	Impacts:                       FieldDescriptor{Name: "impacts", Label: "Impacts", Type: "[]string", InputKey: "impacts", Clearable: true},
	InternalNotes:                 FieldDescriptor{Name: "internal_notes", Label: "InternalNotes", Type: "string", MatchKey: true, InputKey: "internal_notes", Clearable: true},
	InternalOwner:                 FieldDescriptor{Name: "internal_owner", Label: "InternalOwner", Type: "string", MatchKey: true, InputKey: "internal_owner", Clearable: true},
	InternalOwnerGroupID:          FieldDescriptor{Name: "internal_owner_group_id", Label: "InternalOwnerGroupID", Type: "string", MatchKey: true, InputKey: "internal_owner_group_id", Clearable: true},
	InternalOwnerIdentityHolderID: FieldDescriptor{Name: "internal_owner_identity_holder_id", Label: "InternalOwnerIdentityHolderID", Type: "string", MatchKey: true, InputKey: "internal_owner_identity_holder_id", Clearable: true},
	InternalOwnerUserID:           FieldDescriptor{Name: "internal_owner_user_id", Label: "InternalOwnerUserID", Type: "string", MatchKey: true, InputKey: "internal_owner_user_id", Clearable: true},
	ManifestPath:                  FieldDescriptor{Name: "manifest_path", Label: "ManifestPath", Type: "string", MatchKey: true, InputKey: "manifest_path", Clearable: true},
	Metadata:                      FieldDescriptor{Name: "metadata", Label: "Metadata", Type: "map[string]interface {}", InputKey: "metadata", Clearable: true, Volatile: true},
	Open:                          FieldDescriptor{Name: "open", Label: "Open", Type: "bool", WorkflowEligible: true, InputKey: "open", Clearable: true},
	PackageEcosystem:              FieldDescriptor{Name: "package_ecosystem", Label: "PackageEcosystem", Type: "string", MatchKey: true, InputKey: "package_ecosystem", Clearable: true},
	PackageName:                   FieldDescriptor{Name: "package_name", Label: "PackageName", Type: "string", MatchKey: true, InputKey: "package_name", Clearable: true},
	Priority:                      FieldDescriptor{Name: "priority", Label: "Priority", Type: "string", WorkflowEligible: true, MatchKey: true, InputKey: "priority", Clearable: true},
	Production:                    FieldDescriptor{Name: "production", Label: "Production", Type: "bool", WorkflowEligible: true, InputKey: "production", Clearable: true},
	Public:                        FieldDescriptor{Name: "public", Label: "Public", Type: "bool", WorkflowEligible: true, InputKey: "public", Clearable: true},
	PublishedAt:                   FieldDescriptor{Name: "published_at", Label: "PublishedAt", Type: "models.DateTime", InputKey: "published_at", Clearable: true},
	RawPayload:                    FieldDescriptor{Name: "raw_payload", Label: "RawPayload", Type: "map[string]interface {}", InputKey: "raw_payload", Clearable: true, Volatile: true},
	References:                    FieldDescriptor{Name: "references", Label: "References", Type: "[]string", InputKey: "references", Clearable: true},
	RemediationSLA:                FieldDescriptor{Name: "remediation_sla", Label: "RemediationSLA", Type: "int", WorkflowEligible: true, InputKey: "remediation_sla", Clearable: true},
	ReviewedBy:                    FieldDescriptor{Name: "reviewed_by", Label: "ReviewedBy", Type: "string", MatchKey: true, InputKey: "reviewed_by", Clearable: true},
	ReviewedByGroupID:             FieldDescriptor{Name: "reviewed_by_group_id", Label: "ReviewedByGroupID", Type: "string", MatchKey: true, InputKey: "reviewed_by_group_id", Clearable: true},
	ReviewedByIdentityHolderID:    FieldDescriptor{Name: "reviewed_by_identity_holder_id", Label: "ReviewedByIdentityHolderID", Type: "string", MatchKey: true, InputKey: "reviewed_by_identity_holder_id", Clearable: true},
	ReviewedByUserID:              FieldDescriptor{Name: "reviewed_by_user_id", Label: "ReviewedByUserID", Type: "string", MatchKey: true, InputKey: "reviewed_by_user_id", Clearable: true},
	ScopeID:                       FieldDescriptor{Name: "scope_id", Label: "ScopeID", Type: "string", MatchKey: true, InputKey: "scope_id", Clearable: true},
	ScopeName:                     FieldDescriptor{Name: "scope_name", Label: "ScopeName", Type: "string", MatchKey: true, InputKey: "scope_name", Clearable: true, CaseInsensitive: true},
	Score:                         FieldDescriptor{Name: "score", Label: "Score", Type: "float64", WorkflowEligible: true, InputKey: "score", Clearable: true},
	Severity:                      FieldDescriptor{Name: "severity", Label: "Severity", Type: "string", WorkflowEligible: true, MatchKey: true, InputKey: "severity", Clearable: true},
	Source:                        FieldDescriptor{Name: "source", Label: "Source", Type: "string", MatchKey: true, InputKey: "source", Clearable: true},
	SourceUpdatedAt:               FieldDescriptor{Name: "source_updated_at", Label: "SourceUpdatedAt", Type: "models.DateTime", InputKey: "source_updated_at", Clearable: true, Volatile: true},
	Summary:                       FieldDescriptor{Name: "summary", Label: "Summary", Type: "string", MatchKey: true, InputKey: "summary", Clearable: true},
	SystemInternalID:              FieldDescriptor{Name: "system_internal_id", Label: "SystemInternalID", Type: "string", MatchKey: true, InputKey: "system_internal_id", Clearable: true},
	Tags:                          FieldDescriptor{Name: "tags", Label: "Tags", Type: "[]string", InputKey: "tags", Clearable: true},
	Validated:                     FieldDescriptor{Name: "validated", Label: "Validated", Type: "bool", WorkflowEligible: true, InputKey: "validated", Clearable: true},
	Vector:                        FieldDescriptor{Name: "vector", Label: "Vector", Type: "string", MatchKey: true, InputKey: "vector", Clearable: true},
	VulnerabilityStatusID:         FieldDescriptor{Name: "vulnerability_status_id", Label: "VulnerabilityStatusID", Type: "string", MatchKey: true, InputKey: "vulnerability_status_id", Clearable: true},
	VulnerabilityStatusName:       FieldDescriptor{Name: "vulnerability_status_name", Label: "VulnerabilityStatusName", Type: "string", MatchKey: true, InputKey: "vulnerability_status_name", Clearable: true, CaseInsensitive: true},
	VulnerableVersionRange:        FieldDescriptor{Name: "vulnerable_version_range", Label: "VulnerableVersionRange", Type: "string", MatchKey: true, InputKey: "vulnerable_version_range", Clearable: true},
}