|
|
|
|
| package runtime
|
|
|
| import (
|
| "context"
|
| "time"
|
|
|
| "github.com/looplj/axonhub/internal/ent/apikey"
|
| "github.com/looplj/axonhub/internal/ent/channel"
|
| "github.com/looplj/axonhub/internal/ent/channelmodelprice"
|
| "github.com/looplj/axonhub/internal/ent/channelmodelpriceversion"
|
| "github.com/looplj/axonhub/internal/ent/channeloverridetemplate"
|
| "github.com/looplj/axonhub/internal/ent/datastorage"
|
| "github.com/looplj/axonhub/internal/ent/model"
|
| "github.com/looplj/axonhub/internal/ent/project"
|
| "github.com/looplj/axonhub/internal/ent/prompt"
|
| "github.com/looplj/axonhub/internal/ent/providerquotastatus"
|
| "github.com/looplj/axonhub/internal/ent/request"
|
| "github.com/looplj/axonhub/internal/ent/requestexecution"
|
| "github.com/looplj/axonhub/internal/ent/role"
|
| "github.com/looplj/axonhub/internal/ent/schema"
|
| "github.com/looplj/axonhub/internal/ent/system"
|
| "github.com/looplj/axonhub/internal/ent/thread"
|
| "github.com/looplj/axonhub/internal/ent/trace"
|
| "github.com/looplj/axonhub/internal/ent/usagelog"
|
| "github.com/looplj/axonhub/internal/ent/user"
|
| "github.com/looplj/axonhub/internal/ent/userproject"
|
| "github.com/looplj/axonhub/internal/ent/userrole"
|
| "github.com/looplj/axonhub/internal/objects"
|
|
|
| "entgo.io/ent"
|
| "entgo.io/ent/privacy"
|
| )
|
|
|
|
|
|
|
|
|
| func init() {
|
| apikeyMixin := schema.APIKey{}.Mixin()
|
| apikey.Policy = privacy.NewPolicies(schema.APIKey{})
|
| apikey.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := apikey.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| apikeyMixinHooks1 := apikeyMixin[1].Hooks()
|
|
|
| apikey.Hooks[1] = apikeyMixinHooks1[0]
|
| apikeyMixinInters1 := apikeyMixin[1].Interceptors()
|
| apikey.Interceptors[0] = apikeyMixinInters1[0]
|
| apikeyMixinFields0 := apikeyMixin[0].Fields()
|
| _ = apikeyMixinFields0
|
| apikeyMixinFields1 := apikeyMixin[1].Fields()
|
| _ = apikeyMixinFields1
|
| apikeyFields := schema.APIKey{}.Fields()
|
| _ = apikeyFields
|
|
|
| apikeyDescCreatedAt := apikeyMixinFields0[0].Descriptor()
|
|
|
| apikey.DefaultCreatedAt = apikeyDescCreatedAt.Default.(func() time.Time)
|
|
|
| apikeyDescUpdatedAt := apikeyMixinFields0[1].Descriptor()
|
|
|
| apikey.DefaultUpdatedAt = apikeyDescUpdatedAt.Default.(func() time.Time)
|
|
|
| apikey.UpdateDefaultUpdatedAt = apikeyDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| apikeyDescDeletedAt := apikeyMixinFields1[0].Descriptor()
|
|
|
| apikey.DefaultDeletedAt = apikeyDescDeletedAt.Default.(int)
|
|
|
| apikeyDescProjectID := apikeyFields[1].Descriptor()
|
|
|
| apikey.DefaultProjectID = apikeyDescProjectID.Default.(int)
|
|
|
| apikeyDescScopes := apikeyFields[6].Descriptor()
|
|
|
| apikey.DefaultScopes = apikeyDescScopes.Default.([]string)
|
|
|
| apikeyDescProfiles := apikeyFields[7].Descriptor()
|
|
|
| apikey.DefaultProfiles = apikeyDescProfiles.Default.(*objects.APIKeyProfiles)
|
| channelMixin := schema.Channel{}.Mixin()
|
| channel.Policy = privacy.NewPolicies(schema.Channel{})
|
| channel.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := channel.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| channelMixinHooks1 := channelMixin[1].Hooks()
|
|
|
| channel.Hooks[1] = channelMixinHooks1[0]
|
| channelMixinInters1 := channelMixin[1].Interceptors()
|
| channel.Interceptors[0] = channelMixinInters1[0]
|
| channelMixinFields0 := channelMixin[0].Fields()
|
| _ = channelMixinFields0
|
| channelMixinFields1 := channelMixin[1].Fields()
|
| _ = channelMixinFields1
|
| channelFields := schema.Channel{}.Fields()
|
| _ = channelFields
|
|
|
| channelDescCreatedAt := channelMixinFields0[0].Descriptor()
|
|
|
| channel.DefaultCreatedAt = channelDescCreatedAt.Default.(func() time.Time)
|
|
|
| channelDescUpdatedAt := channelMixinFields0[1].Descriptor()
|
|
|
| channel.DefaultUpdatedAt = channelDescUpdatedAt.Default.(func() time.Time)
|
|
|
| channel.UpdateDefaultUpdatedAt = channelDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| channelDescDeletedAt := channelMixinFields1[0].Descriptor()
|
|
|
| channel.DefaultDeletedAt = channelDescDeletedAt.Default.(int)
|
|
|
| channelDescDisabledAPIKeys := channelFields[5].Descriptor()
|
|
|
| channel.DefaultDisabledAPIKeys = channelDescDisabledAPIKeys.Default.([]objects.DisabledAPIKey)
|
|
|
| channelDescAutoSyncSupportedModels := channelFields[7].Descriptor()
|
|
|
| channel.DefaultAutoSyncSupportedModels = channelDescAutoSyncSupportedModels.Default.(bool)
|
|
|
| channelDescTags := channelFields[8].Descriptor()
|
|
|
| channel.DefaultTags = channelDescTags.Default.([]string)
|
|
|
| channelDescPolicies := channelFields[10].Descriptor()
|
|
|
| channel.DefaultPolicies = channelDescPolicies.Default.(objects.ChannelPolicies)
|
|
|
| channelDescSettings := channelFields[11].Descriptor()
|
|
|
| channel.DefaultSettings = channelDescSettings.Default.(*objects.ChannelSettings)
|
|
|
| channelDescOrderingWeight := channelFields[12].Descriptor()
|
|
|
| channel.DefaultOrderingWeight = channelDescOrderingWeight.Default.(int)
|
| channelmodelpriceMixin := schema.ChannelModelPrice{}.Mixin()
|
| channelmodelprice.Policy = privacy.NewPolicies(schema.ChannelModelPrice{})
|
| channelmodelprice.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := channelmodelprice.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| channelmodelpriceMixinHooks1 := channelmodelpriceMixin[1].Hooks()
|
|
|
| channelmodelprice.Hooks[1] = channelmodelpriceMixinHooks1[0]
|
| channelmodelpriceMixinInters1 := channelmodelpriceMixin[1].Interceptors()
|
| channelmodelprice.Interceptors[0] = channelmodelpriceMixinInters1[0]
|
| channelmodelpriceMixinFields0 := channelmodelpriceMixin[0].Fields()
|
| _ = channelmodelpriceMixinFields0
|
| channelmodelpriceMixinFields1 := channelmodelpriceMixin[1].Fields()
|
| _ = channelmodelpriceMixinFields1
|
| channelmodelpriceFields := schema.ChannelModelPrice{}.Fields()
|
| _ = channelmodelpriceFields
|
|
|
| channelmodelpriceDescCreatedAt := channelmodelpriceMixinFields0[0].Descriptor()
|
|
|
| channelmodelprice.DefaultCreatedAt = channelmodelpriceDescCreatedAt.Default.(func() time.Time)
|
|
|
| channelmodelpriceDescUpdatedAt := channelmodelpriceMixinFields0[1].Descriptor()
|
|
|
| channelmodelprice.DefaultUpdatedAt = channelmodelpriceDescUpdatedAt.Default.(func() time.Time)
|
|
|
| channelmodelprice.UpdateDefaultUpdatedAt = channelmodelpriceDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| channelmodelpriceDescDeletedAt := channelmodelpriceMixinFields1[0].Descriptor()
|
|
|
| channelmodelprice.DefaultDeletedAt = channelmodelpriceDescDeletedAt.Default.(int)
|
| channelmodelpriceversionMixin := schema.ChannelModelPriceVersion{}.Mixin()
|
| channelmodelpriceversion.Policy = privacy.NewPolicies(schema.ChannelModelPriceVersion{})
|
| channelmodelpriceversion.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := channelmodelpriceversion.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| channelmodelpriceversionMixinFields0 := channelmodelpriceversionMixin[0].Fields()
|
| _ = channelmodelpriceversionMixinFields0
|
| channelmodelpriceversionFields := schema.ChannelModelPriceVersion{}.Fields()
|
| _ = channelmodelpriceversionFields
|
|
|
| channelmodelpriceversionDescCreatedAt := channelmodelpriceversionMixinFields0[0].Descriptor()
|
|
|
| channelmodelpriceversion.DefaultCreatedAt = channelmodelpriceversionDescCreatedAt.Default.(func() time.Time)
|
|
|
| channelmodelpriceversionDescUpdatedAt := channelmodelpriceversionMixinFields0[1].Descriptor()
|
|
|
| channelmodelpriceversion.DefaultUpdatedAt = channelmodelpriceversionDescUpdatedAt.Default.(func() time.Time)
|
|
|
| channelmodelpriceversion.UpdateDefaultUpdatedAt = channelmodelpriceversionDescUpdatedAt.UpdateDefault.(func() time.Time)
|
| channeloverridetemplateMixin := schema.ChannelOverrideTemplate{}.Mixin()
|
| channeloverridetemplate.Policy = privacy.NewPolicies(schema.ChannelOverrideTemplate{})
|
| channeloverridetemplate.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := channeloverridetemplate.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| channeloverridetemplateMixinHooks1 := channeloverridetemplateMixin[1].Hooks()
|
|
|
| channeloverridetemplate.Hooks[1] = channeloverridetemplateMixinHooks1[0]
|
| channeloverridetemplateMixinInters1 := channeloverridetemplateMixin[1].Interceptors()
|
| channeloverridetemplate.Interceptors[0] = channeloverridetemplateMixinInters1[0]
|
| channeloverridetemplateMixinFields0 := channeloverridetemplateMixin[0].Fields()
|
| _ = channeloverridetemplateMixinFields0
|
| channeloverridetemplateMixinFields1 := channeloverridetemplateMixin[1].Fields()
|
| _ = channeloverridetemplateMixinFields1
|
| channeloverridetemplateFields := schema.ChannelOverrideTemplate{}.Fields()
|
| _ = channeloverridetemplateFields
|
|
|
| channeloverridetemplateDescCreatedAt := channeloverridetemplateMixinFields0[0].Descriptor()
|
|
|
| channeloverridetemplate.DefaultCreatedAt = channeloverridetemplateDescCreatedAt.Default.(func() time.Time)
|
|
|
| channeloverridetemplateDescUpdatedAt := channeloverridetemplateMixinFields0[1].Descriptor()
|
|
|
| channeloverridetemplate.DefaultUpdatedAt = channeloverridetemplateDescUpdatedAt.Default.(func() time.Time)
|
|
|
| channeloverridetemplate.UpdateDefaultUpdatedAt = channeloverridetemplateDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| channeloverridetemplateDescDeletedAt := channeloverridetemplateMixinFields1[0].Descriptor()
|
|
|
| channeloverridetemplate.DefaultDeletedAt = channeloverridetemplateDescDeletedAt.Default.(int)
|
|
|
| channeloverridetemplateDescName := channeloverridetemplateFields[1].Descriptor()
|
|
|
| channeloverridetemplate.NameValidator = channeloverridetemplateDescName.Validators[0].(func(string) error)
|
|
|
| channeloverridetemplateDescOverrideParameters := channeloverridetemplateFields[3].Descriptor()
|
|
|
| channeloverridetemplate.DefaultOverrideParameters = channeloverridetemplateDescOverrideParameters.Default.(string)
|
|
|
| channeloverridetemplateDescOverrideHeaders := channeloverridetemplateFields[4].Descriptor()
|
|
|
| channeloverridetemplate.DefaultOverrideHeaders = channeloverridetemplateDescOverrideHeaders.Default.([]objects.HeaderEntry)
|
|
|
| channeloverridetemplateDescHeaderOverrideOperations := channeloverridetemplateFields[5].Descriptor()
|
|
|
| channeloverridetemplate.DefaultHeaderOverrideOperations = channeloverridetemplateDescHeaderOverrideOperations.Default.([]objects.OverrideOperation)
|
|
|
| channeloverridetemplateDescBodyOverrideOperations := channeloverridetemplateFields[6].Descriptor()
|
|
|
| channeloverridetemplate.DefaultBodyOverrideOperations = channeloverridetemplateDescBodyOverrideOperations.Default.([]objects.OverrideOperation)
|
| datastorageMixin := schema.DataStorage{}.Mixin()
|
| datastorage.Policy = privacy.NewPolicies(schema.DataStorage{})
|
| datastorage.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := datastorage.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| datastorageMixinHooks1 := datastorageMixin[1].Hooks()
|
|
|
| datastorage.Hooks[1] = datastorageMixinHooks1[0]
|
| datastorageMixinInters1 := datastorageMixin[1].Interceptors()
|
| datastorage.Interceptors[0] = datastorageMixinInters1[0]
|
| datastorageMixinFields0 := datastorageMixin[0].Fields()
|
| _ = datastorageMixinFields0
|
| datastorageMixinFields1 := datastorageMixin[1].Fields()
|
| _ = datastorageMixinFields1
|
| datastorageFields := schema.DataStorage{}.Fields()
|
| _ = datastorageFields
|
|
|
| datastorageDescCreatedAt := datastorageMixinFields0[0].Descriptor()
|
|
|
| datastorage.DefaultCreatedAt = datastorageDescCreatedAt.Default.(func() time.Time)
|
|
|
| datastorageDescUpdatedAt := datastorageMixinFields0[1].Descriptor()
|
|
|
| datastorage.DefaultUpdatedAt = datastorageDescUpdatedAt.Default.(func() time.Time)
|
|
|
| datastorage.UpdateDefaultUpdatedAt = datastorageDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| datastorageDescDeletedAt := datastorageMixinFields1[0].Descriptor()
|
|
|
| datastorage.DefaultDeletedAt = datastorageDescDeletedAt.Default.(int)
|
|
|
| datastorageDescPrimary := datastorageFields[2].Descriptor()
|
|
|
| datastorage.DefaultPrimary = datastorageDescPrimary.Default.(bool)
|
| modelMixin := schema.Model{}.Mixin()
|
| model.Policy = privacy.NewPolicies(schema.Model{})
|
| model.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := model.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| modelMixinHooks1 := modelMixin[1].Hooks()
|
|
|
| model.Hooks[1] = modelMixinHooks1[0]
|
| modelMixinInters1 := modelMixin[1].Interceptors()
|
| model.Interceptors[0] = modelMixinInters1[0]
|
| modelMixinFields0 := modelMixin[0].Fields()
|
| _ = modelMixinFields0
|
| modelMixinFields1 := modelMixin[1].Fields()
|
| _ = modelMixinFields1
|
| modelFields := schema.Model{}.Fields()
|
| _ = modelFields
|
|
|
| modelDescCreatedAt := modelMixinFields0[0].Descriptor()
|
|
|
| model.DefaultCreatedAt = modelDescCreatedAt.Default.(func() time.Time)
|
|
|
| modelDescUpdatedAt := modelMixinFields0[1].Descriptor()
|
|
|
| model.DefaultUpdatedAt = modelDescUpdatedAt.Default.(func() time.Time)
|
|
|
| model.UpdateDefaultUpdatedAt = modelDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| modelDescDeletedAt := modelMixinFields1[0].Descriptor()
|
|
|
| model.DefaultDeletedAt = modelDescDeletedAt.Default.(int)
|
| projectMixin := schema.Project{}.Mixin()
|
| project.Policy = privacy.NewPolicies(schema.Project{})
|
| project.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := project.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| projectMixinHooks1 := projectMixin[1].Hooks()
|
|
|
| project.Hooks[1] = projectMixinHooks1[0]
|
| projectMixinInters1 := projectMixin[1].Interceptors()
|
| project.Interceptors[0] = projectMixinInters1[0]
|
| projectMixinFields0 := projectMixin[0].Fields()
|
| _ = projectMixinFields0
|
| projectMixinFields1 := projectMixin[1].Fields()
|
| _ = projectMixinFields1
|
| projectFields := schema.Project{}.Fields()
|
| _ = projectFields
|
|
|
| projectDescCreatedAt := projectMixinFields0[0].Descriptor()
|
|
|
| project.DefaultCreatedAt = projectDescCreatedAt.Default.(func() time.Time)
|
|
|
| projectDescUpdatedAt := projectMixinFields0[1].Descriptor()
|
|
|
| project.DefaultUpdatedAt = projectDescUpdatedAt.Default.(func() time.Time)
|
|
|
| project.UpdateDefaultUpdatedAt = projectDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| projectDescDeletedAt := projectMixinFields1[0].Descriptor()
|
|
|
| project.DefaultDeletedAt = projectDescDeletedAt.Default.(int)
|
|
|
| projectDescDescription := projectFields[1].Descriptor()
|
|
|
| project.DefaultDescription = projectDescDescription.Default.(string)
|
| promptMixin := schema.Prompt{}.Mixin()
|
| prompt.Policy = privacy.NewPolicies(schema.Prompt{})
|
| prompt.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := prompt.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| promptMixinHooks1 := promptMixin[1].Hooks()
|
|
|
| prompt.Hooks[1] = promptMixinHooks1[0]
|
| promptMixinInters1 := promptMixin[1].Interceptors()
|
| prompt.Interceptors[0] = promptMixinInters1[0]
|
| promptMixinFields0 := promptMixin[0].Fields()
|
| _ = promptMixinFields0
|
| promptMixinFields1 := promptMixin[1].Fields()
|
| _ = promptMixinFields1
|
| promptFields := schema.Prompt{}.Fields()
|
| _ = promptFields
|
|
|
| promptDescCreatedAt := promptMixinFields0[0].Descriptor()
|
|
|
| prompt.DefaultCreatedAt = promptDescCreatedAt.Default.(func() time.Time)
|
|
|
| promptDescUpdatedAt := promptMixinFields0[1].Descriptor()
|
|
|
| prompt.DefaultUpdatedAt = promptDescUpdatedAt.Default.(func() time.Time)
|
|
|
| prompt.UpdateDefaultUpdatedAt = promptDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| promptDescDeletedAt := promptMixinFields1[0].Descriptor()
|
|
|
| prompt.DefaultDeletedAt = promptDescDeletedAt.Default.(int)
|
|
|
| promptDescDescription := promptFields[2].Descriptor()
|
|
|
| prompt.DefaultDescription = promptDescDescription.Default.(string)
|
| providerquotastatusMixin := schema.ProviderQuotaStatus{}.Mixin()
|
| providerquotastatusMixinHooks1 := providerquotastatusMixin[1].Hooks()
|
| providerquotastatus.Hooks[0] = providerquotastatusMixinHooks1[0]
|
| providerquotastatusMixinInters1 := providerquotastatusMixin[1].Interceptors()
|
| providerquotastatus.Interceptors[0] = providerquotastatusMixinInters1[0]
|
| providerquotastatusMixinFields0 := providerquotastatusMixin[0].Fields()
|
| _ = providerquotastatusMixinFields0
|
| providerquotastatusMixinFields1 := providerquotastatusMixin[1].Fields()
|
| _ = providerquotastatusMixinFields1
|
| providerquotastatusFields := schema.ProviderQuotaStatus{}.Fields()
|
| _ = providerquotastatusFields
|
|
|
| providerquotastatusDescCreatedAt := providerquotastatusMixinFields0[0].Descriptor()
|
|
|
| providerquotastatus.DefaultCreatedAt = providerquotastatusDescCreatedAt.Default.(func() time.Time)
|
|
|
| providerquotastatusDescUpdatedAt := providerquotastatusMixinFields0[1].Descriptor()
|
|
|
| providerquotastatus.DefaultUpdatedAt = providerquotastatusDescUpdatedAt.Default.(func() time.Time)
|
|
|
| providerquotastatus.UpdateDefaultUpdatedAt = providerquotastatusDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| providerquotastatusDescDeletedAt := providerquotastatusMixinFields1[0].Descriptor()
|
|
|
| providerquotastatus.DefaultDeletedAt = providerquotastatusDescDeletedAt.Default.(int)
|
|
|
| providerquotastatusDescReady := providerquotastatusFields[5].Descriptor()
|
|
|
| providerquotastatus.DefaultReady = providerquotastatusDescReady.Default.(bool)
|
| requestMixin := schema.Request{}.Mixin()
|
| request.Policy = privacy.NewPolicies(schema.Request{})
|
| request.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := request.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| requestMixinFields0 := requestMixin[0].Fields()
|
| _ = requestMixinFields0
|
| requestFields := schema.Request{}.Fields()
|
| _ = requestFields
|
|
|
| requestDescCreatedAt := requestMixinFields0[0].Descriptor()
|
|
|
| request.DefaultCreatedAt = requestDescCreatedAt.Default.(func() time.Time)
|
|
|
| requestDescUpdatedAt := requestMixinFields0[1].Descriptor()
|
|
|
| request.DefaultUpdatedAt = requestDescUpdatedAt.Default.(func() time.Time)
|
|
|
| request.UpdateDefaultUpdatedAt = requestDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| requestDescProjectID := requestFields[1].Descriptor()
|
|
|
| request.DefaultProjectID = requestDescProjectID.Default.(int)
|
|
|
| requestDescFormat := requestFields[6].Descriptor()
|
|
|
| request.DefaultFormat = requestDescFormat.Default.(string)
|
|
|
| requestDescStream := requestFields[14].Descriptor()
|
|
|
| request.DefaultStream = requestDescStream.Default.(bool)
|
|
|
| requestDescClientIP := requestFields[15].Descriptor()
|
|
|
| request.DefaultClientIP = requestDescClientIP.Default.(string)
|
| requestexecutionMixin := schema.RequestExecution{}.Mixin()
|
| requestexecutionMixinFields0 := requestexecutionMixin[0].Fields()
|
| _ = requestexecutionMixinFields0
|
| requestexecutionFields := schema.RequestExecution{}.Fields()
|
| _ = requestexecutionFields
|
|
|
| requestexecutionDescCreatedAt := requestexecutionMixinFields0[0].Descriptor()
|
|
|
| requestexecution.DefaultCreatedAt = requestexecutionDescCreatedAt.Default.(func() time.Time)
|
|
|
| requestexecutionDescUpdatedAt := requestexecutionMixinFields0[1].Descriptor()
|
|
|
| requestexecution.DefaultUpdatedAt = requestexecutionDescUpdatedAt.Default.(func() time.Time)
|
|
|
| requestexecution.UpdateDefaultUpdatedAt = requestexecutionDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| requestexecutionDescProjectID := requestexecutionFields[0].Descriptor()
|
|
|
| requestexecution.DefaultProjectID = requestexecutionDescProjectID.Default.(int)
|
|
|
| requestexecutionDescFormat := requestexecutionFields[6].Descriptor()
|
|
|
| requestexecution.DefaultFormat = requestexecutionDescFormat.Default.(string)
|
|
|
| requestexecutionDescStream := requestexecutionFields[12].Descriptor()
|
|
|
| requestexecution.DefaultStream = requestexecutionDescStream.Default.(bool)
|
| roleMixin := schema.Role{}.Mixin()
|
| role.Policy = privacy.NewPolicies(schema.Role{})
|
| role.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := role.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| roleMixinHooks1 := roleMixin[1].Hooks()
|
|
|
| role.Hooks[1] = roleMixinHooks1[0]
|
| roleMixinInters1 := roleMixin[1].Interceptors()
|
| role.Interceptors[0] = roleMixinInters1[0]
|
| roleMixinFields0 := roleMixin[0].Fields()
|
| _ = roleMixinFields0
|
| roleMixinFields1 := roleMixin[1].Fields()
|
| _ = roleMixinFields1
|
| roleFields := schema.Role{}.Fields()
|
| _ = roleFields
|
|
|
| roleDescCreatedAt := roleMixinFields0[0].Descriptor()
|
|
|
| role.DefaultCreatedAt = roleDescCreatedAt.Default.(func() time.Time)
|
|
|
| roleDescUpdatedAt := roleMixinFields0[1].Descriptor()
|
|
|
| role.DefaultUpdatedAt = roleDescUpdatedAt.Default.(func() time.Time)
|
|
|
| role.UpdateDefaultUpdatedAt = roleDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| roleDescDeletedAt := roleMixinFields1[0].Descriptor()
|
|
|
| role.DefaultDeletedAt = roleDescDeletedAt.Default.(int)
|
|
|
| roleDescScopes := roleFields[3].Descriptor()
|
|
|
| role.DefaultScopes = roleDescScopes.Default.([]string)
|
| systemMixin := schema.System{}.Mixin()
|
| system.Policy = privacy.NewPolicies(schema.System{})
|
| system.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := system.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| systemMixinHooks1 := systemMixin[1].Hooks()
|
|
|
| system.Hooks[1] = systemMixinHooks1[0]
|
| systemMixinInters1 := systemMixin[1].Interceptors()
|
| system.Interceptors[0] = systemMixinInters1[0]
|
| systemMixinFields0 := systemMixin[0].Fields()
|
| _ = systemMixinFields0
|
| systemMixinFields1 := systemMixin[1].Fields()
|
| _ = systemMixinFields1
|
| systemFields := schema.System{}.Fields()
|
| _ = systemFields
|
|
|
| systemDescCreatedAt := systemMixinFields0[0].Descriptor()
|
|
|
| system.DefaultCreatedAt = systemDescCreatedAt.Default.(func() time.Time)
|
|
|
| systemDescUpdatedAt := systemMixinFields0[1].Descriptor()
|
|
|
| system.DefaultUpdatedAt = systemDescUpdatedAt.Default.(func() time.Time)
|
|
|
| system.UpdateDefaultUpdatedAt = systemDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| systemDescDeletedAt := systemMixinFields1[0].Descriptor()
|
|
|
| system.DefaultDeletedAt = systemDescDeletedAt.Default.(int)
|
| threadMixin := schema.Thread{}.Mixin()
|
| thread.Policy = privacy.NewPolicies(schema.Thread{})
|
| thread.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := thread.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| threadMixinFields0 := threadMixin[0].Fields()
|
| _ = threadMixinFields0
|
| threadFields := schema.Thread{}.Fields()
|
| _ = threadFields
|
|
|
| threadDescCreatedAt := threadMixinFields0[0].Descriptor()
|
|
|
| thread.DefaultCreatedAt = threadDescCreatedAt.Default.(func() time.Time)
|
|
|
| threadDescUpdatedAt := threadMixinFields0[1].Descriptor()
|
|
|
| thread.DefaultUpdatedAt = threadDescUpdatedAt.Default.(func() time.Time)
|
|
|
| thread.UpdateDefaultUpdatedAt = threadDescUpdatedAt.UpdateDefault.(func() time.Time)
|
| traceMixin := schema.Trace{}.Mixin()
|
| trace.Policy = privacy.NewPolicies(schema.Trace{})
|
| trace.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := trace.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| traceMixinFields0 := traceMixin[0].Fields()
|
| _ = traceMixinFields0
|
| traceFields := schema.Trace{}.Fields()
|
| _ = traceFields
|
|
|
| traceDescCreatedAt := traceMixinFields0[0].Descriptor()
|
|
|
| trace.DefaultCreatedAt = traceDescCreatedAt.Default.(func() time.Time)
|
|
|
| traceDescUpdatedAt := traceMixinFields0[1].Descriptor()
|
|
|
| trace.DefaultUpdatedAt = traceDescUpdatedAt.Default.(func() time.Time)
|
|
|
| trace.UpdateDefaultUpdatedAt = traceDescUpdatedAt.UpdateDefault.(func() time.Time)
|
| usagelogMixin := schema.UsageLog{}.Mixin()
|
| usagelog.Policy = privacy.NewPolicies(schema.UsageLog{})
|
| usagelog.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := usagelog.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| usagelogMixinFields0 := usagelogMixin[0].Fields()
|
| _ = usagelogMixinFields0
|
| usagelogFields := schema.UsageLog{}.Fields()
|
| _ = usagelogFields
|
|
|
| usagelogDescCreatedAt := usagelogMixinFields0[0].Descriptor()
|
|
|
| usagelog.DefaultCreatedAt = usagelogDescCreatedAt.Default.(func() time.Time)
|
|
|
| usagelogDescUpdatedAt := usagelogMixinFields0[1].Descriptor()
|
|
|
| usagelog.DefaultUpdatedAt = usagelogDescUpdatedAt.Default.(func() time.Time)
|
|
|
| usagelog.UpdateDefaultUpdatedAt = usagelogDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| usagelogDescProjectID := usagelogFields[2].Descriptor()
|
|
|
| usagelog.DefaultProjectID = usagelogDescProjectID.Default.(int)
|
|
|
| usagelogDescPromptTokens := usagelogFields[5].Descriptor()
|
|
|
| usagelog.DefaultPromptTokens = usagelogDescPromptTokens.Default.(int64)
|
|
|
| usagelogDescCompletionTokens := usagelogFields[6].Descriptor()
|
|
|
| usagelog.DefaultCompletionTokens = usagelogDescCompletionTokens.Default.(int64)
|
|
|
| usagelogDescTotalTokens := usagelogFields[7].Descriptor()
|
|
|
| usagelog.DefaultTotalTokens = usagelogDescTotalTokens.Default.(int64)
|
|
|
| usagelogDescPromptAudioTokens := usagelogFields[8].Descriptor()
|
|
|
| usagelog.DefaultPromptAudioTokens = usagelogDescPromptAudioTokens.Default.(int64)
|
|
|
| usagelogDescPromptCachedTokens := usagelogFields[9].Descriptor()
|
|
|
| usagelog.DefaultPromptCachedTokens = usagelogDescPromptCachedTokens.Default.(int64)
|
|
|
| usagelogDescPromptWriteCachedTokens := usagelogFields[10].Descriptor()
|
|
|
| usagelog.DefaultPromptWriteCachedTokens = usagelogDescPromptWriteCachedTokens.Default.(int64)
|
|
|
| usagelogDescPromptWriteCachedTokens5m := usagelogFields[11].Descriptor()
|
|
|
| usagelog.DefaultPromptWriteCachedTokens5m = usagelogDescPromptWriteCachedTokens5m.Default.(int64)
|
|
|
| usagelogDescPromptWriteCachedTokens1h := usagelogFields[12].Descriptor()
|
|
|
| usagelog.DefaultPromptWriteCachedTokens1h = usagelogDescPromptWriteCachedTokens1h.Default.(int64)
|
|
|
| usagelogDescCompletionAudioTokens := usagelogFields[13].Descriptor()
|
|
|
| usagelog.DefaultCompletionAudioTokens = usagelogDescCompletionAudioTokens.Default.(int64)
|
|
|
| usagelogDescCompletionReasoningTokens := usagelogFields[14].Descriptor()
|
|
|
| usagelog.DefaultCompletionReasoningTokens = usagelogDescCompletionReasoningTokens.Default.(int64)
|
|
|
| usagelogDescCompletionAcceptedPredictionTokens := usagelogFields[15].Descriptor()
|
|
|
| usagelog.DefaultCompletionAcceptedPredictionTokens = usagelogDescCompletionAcceptedPredictionTokens.Default.(int64)
|
|
|
| usagelogDescCompletionRejectedPredictionTokens := usagelogFields[16].Descriptor()
|
|
|
| usagelog.DefaultCompletionRejectedPredictionTokens = usagelogDescCompletionRejectedPredictionTokens.Default.(int64)
|
|
|
| usagelogDescFormat := usagelogFields[18].Descriptor()
|
|
|
| usagelog.DefaultFormat = usagelogDescFormat.Default.(string)
|
|
|
| usagelogDescCostItems := usagelogFields[20].Descriptor()
|
|
|
| usagelog.DefaultCostItems = usagelogDescCostItems.Default.([]objects.CostItem)
|
| userMixin := schema.User{}.Mixin()
|
| user.Policy = privacy.NewPolicies(schema.User{})
|
| user.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := user.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| userMixinHooks1 := userMixin[1].Hooks()
|
|
|
| user.Hooks[1] = userMixinHooks1[0]
|
| userMixinInters1 := userMixin[1].Interceptors()
|
| user.Interceptors[0] = userMixinInters1[0]
|
| userMixinFields0 := userMixin[0].Fields()
|
| _ = userMixinFields0
|
| userMixinFields1 := userMixin[1].Fields()
|
| _ = userMixinFields1
|
| userFields := schema.User{}.Fields()
|
| _ = userFields
|
|
|
| userDescCreatedAt := userMixinFields0[0].Descriptor()
|
|
|
| user.DefaultCreatedAt = userDescCreatedAt.Default.(func() time.Time)
|
|
|
| userDescUpdatedAt := userMixinFields0[1].Descriptor()
|
|
|
| user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() time.Time)
|
|
|
| user.UpdateDefaultUpdatedAt = userDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| userDescDeletedAt := userMixinFields1[0].Descriptor()
|
|
|
| user.DefaultDeletedAt = userDescDeletedAt.Default.(int)
|
|
|
| userDescPreferLanguage := userFields[2].Descriptor()
|
|
|
| user.DefaultPreferLanguage = userDescPreferLanguage.Default.(string)
|
|
|
| userDescFirstName := userFields[4].Descriptor()
|
|
|
| user.DefaultFirstName = userDescFirstName.Default.(string)
|
|
|
| userDescLastName := userFields[5].Descriptor()
|
|
|
| user.DefaultLastName = userDescLastName.Default.(string)
|
|
|
| userDescIsOwner := userFields[7].Descriptor()
|
|
|
| user.DefaultIsOwner = userDescIsOwner.Default.(bool)
|
|
|
| userDescScopes := userFields[8].Descriptor()
|
|
|
| user.DefaultScopes = userDescScopes.Default.([]string)
|
| userprojectMixin := schema.UserProject{}.Mixin()
|
| userproject.Policy = privacy.NewPolicies(schema.UserProject{})
|
| userproject.Hooks[0] = func(next ent.Mutator) ent.Mutator {
|
| return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
|
| if err := userproject.Policy.EvalMutation(ctx, m); err != nil {
|
| return nil, err
|
| }
|
| return next.Mutate(ctx, m)
|
| })
|
| }
|
| userprojectMixinFields0 := userprojectMixin[0].Fields()
|
| _ = userprojectMixinFields0
|
| userprojectFields := schema.UserProject{}.Fields()
|
| _ = userprojectFields
|
|
|
| userprojectDescCreatedAt := userprojectMixinFields0[0].Descriptor()
|
|
|
| userproject.DefaultCreatedAt = userprojectDescCreatedAt.Default.(func() time.Time)
|
|
|
| userprojectDescUpdatedAt := userprojectMixinFields0[1].Descriptor()
|
|
|
| userproject.DefaultUpdatedAt = userprojectDescUpdatedAt.Default.(func() time.Time)
|
|
|
| userproject.UpdateDefaultUpdatedAt = userprojectDescUpdatedAt.UpdateDefault.(func() time.Time)
|
|
|
| userprojectDescIsOwner := userprojectFields[2].Descriptor()
|
|
|
| userproject.DefaultIsOwner = userprojectDescIsOwner.Default.(bool)
|
|
|
| userprojectDescScopes := userprojectFields[3].Descriptor()
|
|
|
| userproject.DefaultScopes = userprojectDescScopes.Default.([]string)
|
| userroleFields := schema.UserRole{}.Fields()
|
| _ = userroleFields
|
|
|
| userroleDescCreatedAt := userroleFields[2].Descriptor()
|
|
|
| userrole.DefaultCreatedAt = userroleDescCreatedAt.Default.(func() time.Time)
|
|
|
| userroleDescUpdatedAt := userroleFields[3].Descriptor()
|
|
|
| userrole.DefaultUpdatedAt = userroleDescUpdatedAt.Default.(func() time.Time)
|
|
|
| userrole.UpdateDefaultUpdatedAt = userroleDescUpdatedAt.UpdateDefault.(func() time.Time)
|
| }
|
|
|
| const (
|
| Version = "v0.14.5"
|
| Sum = "h1:Rj2WOYJtCkWyFo6a+5wB3EfBRP0rnx1fMk6gGA0UUe4="
|
| )
|
|
|