From 136c52ed99fbf251c91a50ee35accb7051069488 Mon Sep 17 00:00:00 2001 From: Matt Anderson <42154938+matoszz@users.noreply.github.com> Date: Wed, 11 Dec 2024 13:43:03 -0700 Subject: [PATCH] Feat createtrialsubscription (#307) * subscription creation, entitlements package update * draft new schema * update index * more schema updates * remove object inherited thing * remove struct tag * remove index * nillable * schema rename * add inverse edge * task pr output * fix(deps): update module github.com/theopenlane/utils to v0.4.1 (#283) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> * add new issue form thingy (#288) * fix mismatched names on request and response (#282) * fix mismatched names on request and response, duplicate operations * mockery version update and config file addition to remove deprecation warnings * Update internal/httpserve/handlers/resendemail.go Co-authored-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> Signed-off-by: Matt Anderson <42154938+matoszz@users.noreply.github.com> --------- Signed-off-by: Matt Anderson <42154938+matoszz@users.noreply.github.com> Co-authored-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * limit the builds from renovate (#292) Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * upgrade iam, entx, utils, fix docker build (#296) * upgrade iam, entx, utils, fix docker build Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * put that back Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * dont build everytime Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * correct arch Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> --------- Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * fix(deps): update module github.com/99designs/gqlgen to v0.17.58 (#294) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> * fix deprecated functions from latest gqlen (#298) Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * fix(deps): update module github.com/danielgtaylor/huma/v2 to v2.27.0 (#299) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> * feat: create program members with program (#300) * feat: create program memmbers with program Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * remove extra return def Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * fix idents Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * generate Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> --------- Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * fix(deps): update module github.com/99designs/gqlgen to v0.17.59 (#301) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> * fix(deps): update module github.com/99designs/gqlgen to v0.17.60 (#302) Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> * add create full program, generate-fast (#303) * add create full program, generate-fast Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * add env var to disable cache if wanted, move install to tools.go Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * cleanup generate Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * use fork Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * use fork Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * remove builder line from dockerfile Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * fixup Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * fixup the generate Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> --------- Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> * remove old handlers, cleanup event ordering * Feat betterloggingwrapper (#306) * working version * cleanup, commit whats ready * go mod tidy --------- Signed-off-by: Matt Anderson <42154938+matoszz@users.noreply.github.com> --------- Signed-off-by: Matt Anderson <42154938+matoszz@users.noreply.github.com> Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com> Co-authored-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com> --- .../20241208150023_orgsubscriptions.sql | 23 + db/migrations-goose-postgres/atlas.sum | 3 +- .../20241208150021_orgsubscriptions.sql | 10 + db/migrations/atlas.sum | 3 +- internal/ent/generated/auditing.go | 147 + internal/ent/generated/client.go | 386 +- internal/ent/generated/edge_cleanup.go | 22 + internal/ent/generated/ent.go | 4 + internal/ent/generated/entql.go | 506 +- internal/ent/generated/gql_collection.go | 329 + internal/ent/generated/gql_edge.go | 20 + internal/ent/generated/gql_mutation_input.go | 174 + internal/ent/generated/gql_node.go | 62 + internal/ent/generated/gql_pagination.go | 500 + internal/ent/generated/gql_where_input.go | 1896 + internal/ent/generated/history_client.go | 3 + .../ent/generated/history_from_mutation.go | 273 + internal/ent/generated/history_query.go | 47 + internal/ent/generated/hook/hook.go | 24 + internal/ent/generated/intercept/intercept.go | 60 + .../ent/generated/internal/schemaconfig.go | 2 + internal/ent/generated/migrate/schema.go | 78 + internal/ent/generated/mutation.go | 3364 +- internal/ent/generated/organization.go | 101 +- .../generated/organization/organization.go | 30 + internal/ent/generated/organization/where.go | 29 + internal/ent/generated/organization_create.go | 33 + internal/ent/generated/organization_query.go | 103 +- internal/ent/generated/organization_update.go | 169 + internal/ent/generated/orgsubscription.go | 323 + .../orgsubscription/orgsubscription.go | 218 + .../ent/generated/orgsubscription/where.go | 1157 + .../ent/generated/orgsubscription_create.go | 557 + .../ent/generated/orgsubscription_delete.go | 92 + .../ent/generated/orgsubscription_query.go | 647 + .../ent/generated/orgsubscription_update.go | 1046 + .../ent/generated/orgsubscriptionhistory.go | 328 + .../orgsubscriptionhistory.go | 230 + .../generated/orgsubscriptionhistory/where.go | 1271 + .../orgsubscriptionhistory_create.go | 579 + .../orgsubscriptionhistory_delete.go | 92 + .../generated/orgsubscriptionhistory_query.go | 565 + .../orgsubscriptionhistory_update.go | 941 + internal/ent/generated/predicate/predicate.go | 6 + internal/ent/generated/privacy/privacy.go | 56 + internal/ent/generated/runtime/runtime.go | 85 + internal/ent/generated/tx.go | 6 + internal/ent/hooks/event.go | 79 +- internal/ent/schema/organization.go | 5 +- internal/ent/schema/orgsubscription.go | 102 + .../ent/schema/orgsubscription_history.go | 90 + internal/graphapi/adminsearch.resolvers.go | 23 + internal/graphapi/bulk.go | 19 + internal/graphapi/ent.resolvers.go | 32 + internal/graphapi/gen_models.go | 30 + internal/graphapi/gen_server.go | 37430 ++++++++++------ .../graphapi/orgsubscription.resolvers.go | 101 + internal/graphapi/search.go | 38 + internal/graphapi/search.resolvers.go | 23 + internal/httpserve/handlers/checkout.go | 114 - internal/httpserve/handlers/ent.go | 37 - internal/httpserve/route/checkout.go | 53 - internal/httpserve/route/router.go | 7 - pkg/entitlements/customers.go | 13 + pkg/entitlements/helpers.go | 14 +- pkg/entitlements/models.go | 22 +- pkg/entitlements/subscriptions.go | 44 +- pkg/entitlements/test/main.go | 11 + pkg/entitlements/test/plans.yaml | 105 +- pkg/openlaneclient/graphclient.go | 1837 + pkg/openlaneclient/models.go | 654 + query/adminsearch.graphql | 14 + query/orgsubscription.graphql | 161 + query/orgsubscriptionhistory.graphql | 55 + query/search.graphql | 6 + schema.graphql | 1344 +- schema/adminsearch.graphql | 9 + schema/ent.graphql | 1242 +- schema/orgsubscription.graphql | 103 + schema/search.graphql | 14 + 80 files changed, 45879 insertions(+), 14552 deletions(-) create mode 100644 db/migrations-goose-postgres/20241208150023_orgsubscriptions.sql create mode 100644 db/migrations/20241208150021_orgsubscriptions.sql create mode 100644 internal/ent/generated/orgsubscription.go create mode 100644 internal/ent/generated/orgsubscription/orgsubscription.go create mode 100644 internal/ent/generated/orgsubscription/where.go create mode 100644 internal/ent/generated/orgsubscription_create.go create mode 100644 internal/ent/generated/orgsubscription_delete.go create mode 100644 internal/ent/generated/orgsubscription_query.go create mode 100644 internal/ent/generated/orgsubscription_update.go create mode 100644 internal/ent/generated/orgsubscriptionhistory.go create mode 100644 internal/ent/generated/orgsubscriptionhistory/orgsubscriptionhistory.go create mode 100644 internal/ent/generated/orgsubscriptionhistory/where.go create mode 100644 internal/ent/generated/orgsubscriptionhistory_create.go create mode 100644 internal/ent/generated/orgsubscriptionhistory_delete.go create mode 100644 internal/ent/generated/orgsubscriptionhistory_query.go create mode 100644 internal/ent/generated/orgsubscriptionhistory_update.go create mode 100644 internal/ent/schema/orgsubscription.go create mode 100644 internal/ent/schema/orgsubscription_history.go create mode 100644 internal/graphapi/orgsubscription.resolvers.go delete mode 100644 internal/httpserve/handlers/checkout.go delete mode 100644 internal/httpserve/route/checkout.go create mode 100644 query/orgsubscription.graphql create mode 100644 query/orgsubscriptionhistory.graphql create mode 100644 schema/orgsubscription.graphql diff --git a/db/migrations-goose-postgres/20241208150023_orgsubscriptions.sql b/db/migrations-goose-postgres/20241208150023_orgsubscriptions.sql new file mode 100644 index 00000000..d7c82531 --- /dev/null +++ b/db/migrations-goose-postgres/20241208150023_orgsubscriptions.sql @@ -0,0 +1,23 @@ +-- +goose Up +-- create "org_subscription_history" table +CREATE TABLE "org_subscription_history" ("id" character varying NOT NULL, "history_time" timestamptz NOT NULL, "ref" character varying NULL, "operation" character varying NOT NULL, "created_at" timestamptz NULL, "updated_at" timestamptz NULL, "created_by" character varying NULL, "updated_by" character varying NULL, "mapping_id" character varying NOT NULL, "tags" jsonb NULL, "deleted_at" timestamptz NULL, "deleted_by" character varying NULL, "owner_id" character varying NULL, "stripe_subscription_id" character varying NULL, "product_tier" character varying NULL, "stripe_product_tier_id" character varying NULL, "stripe_subscription_status" character varying NULL, "active" boolean NOT NULL DEFAULT true, "stripe_customer_id" character varying NULL, "expires_at" timestamptz NULL, "features" jsonb NULL, PRIMARY KEY ("id")); +-- create index "orgsubscriptionhistory_history_time" to table: "org_subscription_history" +CREATE INDEX "orgsubscriptionhistory_history_time" ON "org_subscription_history" ("history_time"); +-- create "org_subscriptions" table +CREATE TABLE "org_subscriptions" ("id" character varying NOT NULL, "created_at" timestamptz NULL, "updated_at" timestamptz NULL, "created_by" character varying NULL, "updated_by" character varying NULL, "mapping_id" character varying NOT NULL, "tags" jsonb NULL, "deleted_at" timestamptz NULL, "deleted_by" character varying NULL, "stripe_subscription_id" character varying NULL, "product_tier" character varying NULL, "stripe_product_tier_id" character varying NULL, "stripe_subscription_status" character varying NULL, "active" boolean NOT NULL DEFAULT true, "stripe_customer_id" character varying NULL, "expires_at" timestamptz NULL, "features" jsonb NULL, "owner_id" character varying NULL, PRIMARY KEY ("id"), CONSTRAINT "org_subscriptions_organizations_orgsubscriptions" FOREIGN KEY ("owner_id") REFERENCES "organizations" ("id") ON UPDATE NO ACTION ON DELETE SET NULL); +-- create index "org_subscriptions_mapping_id_key" to table: "org_subscriptions" +CREATE UNIQUE INDEX "org_subscriptions_mapping_id_key" ON "org_subscriptions" ("mapping_id"); +-- create index "org_subscriptions_stripe_customer_id_key" to table: "org_subscriptions" +CREATE UNIQUE INDEX "org_subscriptions_stripe_customer_id_key" ON "org_subscriptions" ("stripe_customer_id"); + +-- +goose Down +-- reverse: create index "org_subscriptions_stripe_customer_id_key" to table: "org_subscriptions" +DROP INDEX "org_subscriptions_stripe_customer_id_key"; +-- reverse: create index "org_subscriptions_mapping_id_key" to table: "org_subscriptions" +DROP INDEX "org_subscriptions_mapping_id_key"; +-- reverse: create "org_subscriptions" table +DROP TABLE "org_subscriptions"; +-- reverse: create index "orgsubscriptionhistory_history_time" to table: "org_subscription_history" +DROP INDEX "orgsubscriptionhistory_history_time"; +-- reverse: create "org_subscription_history" table +DROP TABLE "org_subscription_history"; diff --git a/db/migrations-goose-postgres/atlas.sum b/db/migrations-goose-postgres/atlas.sum index f2d81358..1e0803bf 100644 --- a/db/migrations-goose-postgres/atlas.sum +++ b/db/migrations-goose-postgres/atlas.sum @@ -1,4 +1,4 @@ -h1:KRzZoIIUgdqdpTFvoiiWd5WmhulDcNcfzhLCY4q5qus= +h1:Fz9zuMpP/IUJo4CRvWeH9Wl491SxVSKi0xzooAedS3k= 20240827061503_init.sql h1:D0Ce7h0FSKpjtQOHZK5gXOpaPvlNAFHHzqfQQ8re0T4= 20241014185634_object_upload.sql h1:xeeCqYCpQ3RFWgNjnKV1GMHgTEoZK2aWv5a2EvU4DP8= 20241030173034_base.sql h1:+eJ3JGD5lzsP16mz7q+yD78Jvs7sTX8nBZQmS68hjoA= @@ -13,3 +13,4 @@ h1:KRzZoIIUgdqdpTFvoiiWd5WmhulDcNcfzhLCY4q5qus= 20241201194400_controls.sql h1:kRChIRC5+5qzcD8IXSIpp7dt1w/xvhBw7F0+YiEoFUc= 20241203221236_creator_groups.sql h1:NNAIP7ISaBf1HuZgPhkGnf8yfLrpps9QY+1UOdSTp3o= 20241204061533_subcontrols.sql h1:gVm6Nxppr9Eh+bhloxn9+NRKYH3vJB9WKSzqD7O3TEI= +20241208150023_orgsubscriptions.sql h1:QUNTzFjvz4B6BIlkgx2IN2i1l2M4iQ/HLfZk+cRN0D8= diff --git a/db/migrations/20241208150021_orgsubscriptions.sql b/db/migrations/20241208150021_orgsubscriptions.sql new file mode 100644 index 00000000..9c44a362 --- /dev/null +++ b/db/migrations/20241208150021_orgsubscriptions.sql @@ -0,0 +1,10 @@ +-- Create "org_subscription_history" table +CREATE TABLE "org_subscription_history" ("id" character varying NOT NULL, "history_time" timestamptz NOT NULL, "ref" character varying NULL, "operation" character varying NOT NULL, "created_at" timestamptz NULL, "updated_at" timestamptz NULL, "created_by" character varying NULL, "updated_by" character varying NULL, "mapping_id" character varying NOT NULL, "tags" jsonb NULL, "deleted_at" timestamptz NULL, "deleted_by" character varying NULL, "owner_id" character varying NULL, "stripe_subscription_id" character varying NULL, "product_tier" character varying NULL, "stripe_product_tier_id" character varying NULL, "stripe_subscription_status" character varying NULL, "active" boolean NOT NULL DEFAULT true, "stripe_customer_id" character varying NULL, "expires_at" timestamptz NULL, "features" jsonb NULL, PRIMARY KEY ("id")); +-- Create index "orgsubscriptionhistory_history_time" to table: "org_subscription_history" +CREATE INDEX "orgsubscriptionhistory_history_time" ON "org_subscription_history" ("history_time"); +-- Create "org_subscriptions" table +CREATE TABLE "org_subscriptions" ("id" character varying NOT NULL, "created_at" timestamptz NULL, "updated_at" timestamptz NULL, "created_by" character varying NULL, "updated_by" character varying NULL, "mapping_id" character varying NOT NULL, "tags" jsonb NULL, "deleted_at" timestamptz NULL, "deleted_by" character varying NULL, "stripe_subscription_id" character varying NULL, "product_tier" character varying NULL, "stripe_product_tier_id" character varying NULL, "stripe_subscription_status" character varying NULL, "active" boolean NOT NULL DEFAULT true, "stripe_customer_id" character varying NULL, "expires_at" timestamptz NULL, "features" jsonb NULL, "owner_id" character varying NULL, PRIMARY KEY ("id"), CONSTRAINT "org_subscriptions_organizations_orgsubscriptions" FOREIGN KEY ("owner_id") REFERENCES "organizations" ("id") ON UPDATE NO ACTION ON DELETE SET NULL); +-- Create index "org_subscriptions_mapping_id_key" to table: "org_subscriptions" +CREATE UNIQUE INDEX "org_subscriptions_mapping_id_key" ON "org_subscriptions" ("mapping_id"); +-- Create index "org_subscriptions_stripe_customer_id_key" to table: "org_subscriptions" +CREATE UNIQUE INDEX "org_subscriptions_stripe_customer_id_key" ON "org_subscriptions" ("stripe_customer_id"); diff --git a/db/migrations/atlas.sum b/db/migrations/atlas.sum index 86e7dd9b..8c645162 100644 --- a/db/migrations/atlas.sum +++ b/db/migrations/atlas.sum @@ -1,4 +1,4 @@ -h1:Nj8o8IUgf/f2Z1TSIV+XhC6Ov1STXzZBjyTqj/XtjUk= +h1:qs8r4p4lJWKQ35uTsZqXNe9IP/IrEjb370WnlGUMNdQ= 20240827061437_init.sql h1:9pQTZIsiDF3hW0HraVTzaU3M25iiy3MdxvhsZosxgvo= 20241014185633_object_upload.sql h1:0lzY0vj0gav3gMHGc8gm793zPeSQSMMHjt4c2V+7Eok= 20241108062010_compliance.sql h1:vmJyf1VhoKSRw9zRQKXsRtWJEEUYDbqZmpkyp89O/Tc= @@ -12,3 +12,4 @@ h1:Nj8o8IUgf/f2Z1TSIV+XhC6Ov1STXzZBjyTqj/XtjUk= 20241201194355_controls.sql h1:lArKSEyGAIbk0Up6B7/RZTTZgVlB+rE09yJxQvK+30A= 20241203221235_creator_groups.sql h1:a6tKXzTkd+TlOgCfL/Iojb3zAU1DCQ5odiKw6nJvFRw= 20241204061531_subcontrols.sql h1:D+3+ALb+fU/3YugzAwxLMMjQLbniaHLlWaVgEHDwCYQ= +20241208150021_orgsubscriptions.sql h1:mXL7jQ8nE0q77OqFB5gRydrDuJu4hZCHRHhXGlm99oM= diff --git a/internal/ent/generated/auditing.go b/internal/ent/generated/auditing.go index 9ee357a5..53215853 100644 --- a/internal/ent/generated/auditing.go +++ b/internal/ent/generated/auditing.go @@ -37,6 +37,7 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationhistory" "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/procedurehistory" "github.com/theopenlane/core/internal/ent/generated/programhistory" "github.com/theopenlane/core/internal/ent/generated/programmembershiphistory" @@ -1696,6 +1697,84 @@ func (omh *OrgMembershipHistory) Diff(history *OrgMembershipHistory) (*HistoryDi return nil, IdenticalHistoryError } +func (osh *OrgSubscriptionHistory) changes(new *OrgSubscriptionHistory) []Change { + var changes []Change + if !reflect.DeepEqual(osh.CreatedAt, new.CreatedAt) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldCreatedAt, osh.CreatedAt, new.CreatedAt)) + } + if !reflect.DeepEqual(osh.UpdatedAt, new.UpdatedAt) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldUpdatedAt, osh.UpdatedAt, new.UpdatedAt)) + } + if !reflect.DeepEqual(osh.CreatedBy, new.CreatedBy) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldCreatedBy, osh.CreatedBy, new.CreatedBy)) + } + if !reflect.DeepEqual(osh.MappingID, new.MappingID) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldMappingID, osh.MappingID, new.MappingID)) + } + if !reflect.DeepEqual(osh.Tags, new.Tags) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldTags, osh.Tags, new.Tags)) + } + if !reflect.DeepEqual(osh.DeletedAt, new.DeletedAt) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldDeletedAt, osh.DeletedAt, new.DeletedAt)) + } + if !reflect.DeepEqual(osh.DeletedBy, new.DeletedBy) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldDeletedBy, osh.DeletedBy, new.DeletedBy)) + } + if !reflect.DeepEqual(osh.OwnerID, new.OwnerID) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldOwnerID, osh.OwnerID, new.OwnerID)) + } + if !reflect.DeepEqual(osh.StripeSubscriptionID, new.StripeSubscriptionID) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldStripeSubscriptionID, osh.StripeSubscriptionID, new.StripeSubscriptionID)) + } + if !reflect.DeepEqual(osh.ProductTier, new.ProductTier) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldProductTier, osh.ProductTier, new.ProductTier)) + } + if !reflect.DeepEqual(osh.StripeProductTierID, new.StripeProductTierID) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldStripeProductTierID, osh.StripeProductTierID, new.StripeProductTierID)) + } + if !reflect.DeepEqual(osh.StripeSubscriptionStatus, new.StripeSubscriptionStatus) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldStripeSubscriptionStatus, osh.StripeSubscriptionStatus, new.StripeSubscriptionStatus)) + } + if !reflect.DeepEqual(osh.Active, new.Active) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldActive, osh.Active, new.Active)) + } + if !reflect.DeepEqual(osh.StripeCustomerID, new.StripeCustomerID) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldStripeCustomerID, osh.StripeCustomerID, new.StripeCustomerID)) + } + if !reflect.DeepEqual(osh.ExpiresAt, new.ExpiresAt) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldExpiresAt, osh.ExpiresAt, new.ExpiresAt)) + } + if !reflect.DeepEqual(osh.Features, new.Features) { + changes = append(changes, NewChange(orgsubscriptionhistory.FieldFeatures, osh.Features, new.Features)) + } + return changes +} + +func (osh *OrgSubscriptionHistory) Diff(history *OrgSubscriptionHistory) (*HistoryDiff[OrgSubscriptionHistory], error) { + if osh.Ref != history.Ref { + return nil, MismatchedRefError + } + + oshUnix, historyUnix := osh.HistoryTime.Unix(), history.HistoryTime.Unix() + oshOlder := oshUnix < historyUnix || (oshUnix == historyUnix && osh.ID < history.ID) + historyOlder := oshUnix > historyUnix || (oshUnix == historyUnix && osh.ID > history.ID) + + if oshOlder { + return &HistoryDiff[OrgSubscriptionHistory]{ + Old: osh, + New: history, + Changes: osh.changes(history), + }, nil + } else if historyOlder { + return &HistoryDiff[OrgSubscriptionHistory]{ + Old: history, + New: osh, + Changes: history.changes(osh), + }, nil + } + return nil, IdenticalHistoryError +} + func (oh *OrganizationHistory) changes(new *OrganizationHistory) []Change { var changes []Change if !reflect.DeepEqual(oh.CreatedAt, new.CreatedAt) { @@ -2891,6 +2970,12 @@ func (c *Client) Audit(ctx context.Context) ([][]string, error) { } records = append(records, record...) + record, err = auditOrgSubscriptionHistory(ctx, c.config) + if err != nil { + return nil, err + } + records = append(records, record...) + record, err = auditOrganizationHistory(ctx, c.config) if err != nil { return nil, err @@ -3186,6 +3271,15 @@ func (c *Client) AuditWithFilter(ctx context.Context, tableName string) ([][]str records = append(records, record...) } + if tableName == "" || tableName == strings.TrimSuffix("OrgSubscriptionHistory", "History") { + record, err = auditOrgSubscriptionHistory(ctx, c.config) + if err != nil { + return nil, err + } + + records = append(records, record...) + } + if tableName == "" || tableName == strings.TrimSuffix("OrganizationHistory", "History") { record, err = auditOrganizationHistory(ctx, c.config) if err != nil { @@ -4554,6 +4648,59 @@ func auditOrgMembershipHistory(ctx context.Context, config config) ([][]string, return records, nil } +type orgsubscriptionhistoryref struct { + Ref string +} + +func auditOrgSubscriptionHistory(ctx context.Context, config config) ([][]string, error) { + var records = [][]string{} + var refs []orgsubscriptionhistoryref + client := NewOrgSubscriptionHistoryClient(config) + err := client.Query(). + Unique(true). + Order(orgsubscriptionhistory.ByRef()). + Select(orgsubscriptionhistory.FieldRef). + Scan(ctx, &refs) + + if err != nil { + return nil, err + } + for _, currRef := range refs { + histories, err := client.Query(). + Where(orgsubscriptionhistory.Ref(currRef.Ref)). + Order(orgsubscriptionhistory.ByHistoryTime()). + All(ctx) + if err != nil { + return nil, err + } + + for i := 0; i < len(histories); i++ { + curr := histories[i] + record := record{ + Table: "OrgSubscriptionHistory", + RefId: curr.Ref, + HistoryTime: curr.HistoryTime, + Operation: curr.Operation, + UpdatedBy: curr.UpdatedBy, + } + switch curr.Operation { + case history.OpTypeInsert: + record.Changes = (&OrgSubscriptionHistory{}).changes(curr) + case history.OpTypeDelete: + record.Changes = curr.changes(&OrgSubscriptionHistory{}) + default: + if i == 0 { + record.Changes = (&OrgSubscriptionHistory{}).changes(curr) + } else { + record.Changes = histories[i-1].changes(curr) + } + } + records = append(records, record.toRow()) + } + } + return records, nil +} + type organizationhistoryref struct { Ref string } diff --git a/internal/ent/generated/client.go b/internal/ent/generated/client.go index e7980b12..1c4f8860 100644 --- a/internal/ent/generated/client.go +++ b/internal/ent/generated/client.go @@ -73,6 +73,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/passwordresettoken" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/procedure" @@ -220,6 +222,10 @@ type Client struct { OrgMembership *OrgMembershipClient // OrgMembershipHistory is the client for interacting with the OrgMembershipHistory builders. OrgMembershipHistory *OrgMembershipHistoryClient + // OrgSubscription is the client for interacting with the OrgSubscription builders. + OrgSubscription *OrgSubscriptionClient + // OrgSubscriptionHistory is the client for interacting with the OrgSubscriptionHistory builders. + OrgSubscriptionHistory *OrgSubscriptionHistoryClient // Organization is the client for interacting with the Organization builders. Organization *OrganizationClient // OrganizationHistory is the client for interacting with the OrganizationHistory builders. @@ -352,6 +358,8 @@ func (c *Client) init() { c.OhAuthTooToken = NewOhAuthTooTokenClient(c.config) c.OrgMembership = NewOrgMembershipClient(c.config) c.OrgMembershipHistory = NewOrgMembershipHistoryClient(c.config) + c.OrgSubscription = NewOrgSubscriptionClient(c.config) + c.OrgSubscriptionHistory = NewOrgSubscriptionHistoryClient(c.config) c.Organization = NewOrganizationClient(c.config) c.OrganizationHistory = NewOrganizationHistoryClient(c.config) c.OrganizationSetting = NewOrganizationSettingClient(c.config) @@ -594,6 +602,8 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) { OhAuthTooToken: NewOhAuthTooTokenClient(cfg), OrgMembership: NewOrgMembershipClient(cfg), OrgMembershipHistory: NewOrgMembershipHistoryClient(cfg), + OrgSubscription: NewOrgSubscriptionClient(cfg), + OrgSubscriptionHistory: NewOrgSubscriptionHistoryClient(cfg), Organization: NewOrganizationClient(cfg), OrganizationHistory: NewOrganizationHistoryClient(cfg), OrganizationSetting: NewOrganizationSettingClient(cfg), @@ -694,6 +704,8 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) OhAuthTooToken: NewOhAuthTooTokenClient(cfg), OrgMembership: NewOrgMembershipClient(cfg), OrgMembershipHistory: NewOrgMembershipHistoryClient(cfg), + OrgSubscription: NewOrgSubscriptionClient(cfg), + OrgSubscriptionHistory: NewOrgSubscriptionHistoryClient(cfg), Organization: NewOrganizationClient(cfg), OrganizationHistory: NewOrganizationHistoryClient(cfg), OrganizationSetting: NewOrganizationSettingClient(cfg), @@ -766,14 +778,15 @@ func (c *Client) Use(hooks ...Hook) { c.IntegrationHistory, c.InternalPolicy, c.InternalPolicyHistory, c.Invite, c.Narrative, c.NarrativeHistory, c.Note, c.NoteHistory, c.OauthProvider, c.OauthProviderHistory, c.OhAuthTooToken, c.OrgMembership, - c.OrgMembershipHistory, c.Organization, c.OrganizationHistory, - c.OrganizationSetting, c.OrganizationSettingHistory, c.PasswordResetToken, - c.PersonalAccessToken, c.Procedure, c.ProcedureHistory, c.Program, - c.ProgramHistory, c.ProgramMembership, c.ProgramMembershipHistory, c.Risk, - c.RiskHistory, c.Standard, c.StandardHistory, c.Subcontrol, - c.SubcontrolHistory, c.Subscriber, c.TFASetting, c.Task, c.TaskHistory, - c.Template, c.TemplateHistory, c.User, c.UserHistory, c.UserSetting, - c.UserSettingHistory, c.Webauthn, c.Webhook, c.WebhookHistory, + c.OrgMembershipHistory, c.OrgSubscription, c.OrgSubscriptionHistory, + c.Organization, c.OrganizationHistory, c.OrganizationSetting, + c.OrganizationSettingHistory, c.PasswordResetToken, c.PersonalAccessToken, + c.Procedure, c.ProcedureHistory, c.Program, c.ProgramHistory, + c.ProgramMembership, c.ProgramMembershipHistory, c.Risk, c.RiskHistory, + c.Standard, c.StandardHistory, c.Subcontrol, c.SubcontrolHistory, c.Subscriber, + c.TFASetting, c.Task, c.TaskHistory, c.Template, c.TemplateHistory, c.User, + c.UserHistory, c.UserSetting, c.UserSettingHistory, c.Webauthn, c.Webhook, + c.WebhookHistory, } { n.Use(hooks...) } @@ -795,14 +808,15 @@ func (c *Client) Intercept(interceptors ...Interceptor) { c.IntegrationHistory, c.InternalPolicy, c.InternalPolicyHistory, c.Invite, c.Narrative, c.NarrativeHistory, c.Note, c.NoteHistory, c.OauthProvider, c.OauthProviderHistory, c.OhAuthTooToken, c.OrgMembership, - c.OrgMembershipHistory, c.Organization, c.OrganizationHistory, - c.OrganizationSetting, c.OrganizationSettingHistory, c.PasswordResetToken, - c.PersonalAccessToken, c.Procedure, c.ProcedureHistory, c.Program, - c.ProgramHistory, c.ProgramMembership, c.ProgramMembershipHistory, c.Risk, - c.RiskHistory, c.Standard, c.StandardHistory, c.Subcontrol, - c.SubcontrolHistory, c.Subscriber, c.TFASetting, c.Task, c.TaskHistory, - c.Template, c.TemplateHistory, c.User, c.UserHistory, c.UserSetting, - c.UserSettingHistory, c.Webauthn, c.Webhook, c.WebhookHistory, + c.OrgMembershipHistory, c.OrgSubscription, c.OrgSubscriptionHistory, + c.Organization, c.OrganizationHistory, c.OrganizationSetting, + c.OrganizationSettingHistory, c.PasswordResetToken, c.PersonalAccessToken, + c.Procedure, c.ProcedureHistory, c.Program, c.ProgramHistory, + c.ProgramMembership, c.ProgramMembershipHistory, c.Risk, c.RiskHistory, + c.Standard, c.StandardHistory, c.Subcontrol, c.SubcontrolHistory, c.Subscriber, + c.TFASetting, c.Task, c.TaskHistory, c.Template, c.TemplateHistory, c.User, + c.UserHistory, c.UserSetting, c.UserSettingHistory, c.Webauthn, c.Webhook, + c.WebhookHistory, } { n.Intercept(interceptors...) } @@ -983,6 +997,10 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) { return c.OrgMembership.mutate(ctx, m) case *OrgMembershipHistoryMutation: return c.OrgMembershipHistory.mutate(ctx, m) + case *OrgSubscriptionMutation: + return c.OrgSubscription.mutate(ctx, m) + case *OrgSubscriptionHistoryMutation: + return c.OrgSubscriptionHistory.mutate(ctx, m) case *OrganizationMutation: return c.Organization.mutate(ctx, m) case *OrganizationHistoryMutation: @@ -11040,6 +11058,293 @@ func (c *OrgMembershipHistoryClient) mutate(ctx context.Context, m *OrgMembershi } } +// OrgSubscriptionClient is a client for the OrgSubscription schema. +type OrgSubscriptionClient struct { + config +} + +// NewOrgSubscriptionClient returns a client for the OrgSubscription from the given config. +func NewOrgSubscriptionClient(c config) *OrgSubscriptionClient { + return &OrgSubscriptionClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `orgsubscription.Hooks(f(g(h())))`. +func (c *OrgSubscriptionClient) Use(hooks ...Hook) { + c.hooks.OrgSubscription = append(c.hooks.OrgSubscription, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `orgsubscription.Intercept(f(g(h())))`. +func (c *OrgSubscriptionClient) Intercept(interceptors ...Interceptor) { + c.inters.OrgSubscription = append(c.inters.OrgSubscription, interceptors...) +} + +// Create returns a builder for creating a OrgSubscription entity. +func (c *OrgSubscriptionClient) Create() *OrgSubscriptionCreate { + mutation := newOrgSubscriptionMutation(c.config, OpCreate) + return &OrgSubscriptionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of OrgSubscription entities. +func (c *OrgSubscriptionClient) CreateBulk(builders ...*OrgSubscriptionCreate) *OrgSubscriptionCreateBulk { + return &OrgSubscriptionCreateBulk{config: c.config, builders: builders} +} + +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *OrgSubscriptionClient) MapCreateBulk(slice any, setFunc func(*OrgSubscriptionCreate, int)) *OrgSubscriptionCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &OrgSubscriptionCreateBulk{err: fmt.Errorf("calling to OrgSubscriptionClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*OrgSubscriptionCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &OrgSubscriptionCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for OrgSubscription. +func (c *OrgSubscriptionClient) Update() *OrgSubscriptionUpdate { + mutation := newOrgSubscriptionMutation(c.config, OpUpdate) + return &OrgSubscriptionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *OrgSubscriptionClient) UpdateOne(os *OrgSubscription) *OrgSubscriptionUpdateOne { + mutation := newOrgSubscriptionMutation(c.config, OpUpdateOne, withOrgSubscription(os)) + return &OrgSubscriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *OrgSubscriptionClient) UpdateOneID(id string) *OrgSubscriptionUpdateOne { + mutation := newOrgSubscriptionMutation(c.config, OpUpdateOne, withOrgSubscriptionID(id)) + return &OrgSubscriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for OrgSubscription. +func (c *OrgSubscriptionClient) Delete() *OrgSubscriptionDelete { + mutation := newOrgSubscriptionMutation(c.config, OpDelete) + return &OrgSubscriptionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *OrgSubscriptionClient) DeleteOne(os *OrgSubscription) *OrgSubscriptionDeleteOne { + return c.DeleteOneID(os.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *OrgSubscriptionClient) DeleteOneID(id string) *OrgSubscriptionDeleteOne { + builder := c.Delete().Where(orgsubscription.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &OrgSubscriptionDeleteOne{builder} +} + +// Query returns a query builder for OrgSubscription. +func (c *OrgSubscriptionClient) Query() *OrgSubscriptionQuery { + return &OrgSubscriptionQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeOrgSubscription}, + inters: c.Interceptors(), + } +} + +// Get returns a OrgSubscription entity by its id. +func (c *OrgSubscriptionClient) Get(ctx context.Context, id string) (*OrgSubscription, error) { + return c.Query().Where(orgsubscription.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *OrgSubscriptionClient) GetX(ctx context.Context, id string) *OrgSubscription { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// QueryOwner queries the owner edge of a OrgSubscription. +func (c *OrgSubscriptionClient) QueryOwner(os *OrgSubscription) *OrganizationQuery { + query := (&OrganizationClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := os.ID + step := sqlgraph.NewStep( + sqlgraph.From(orgsubscription.Table, orgsubscription.FieldID, id), + sqlgraph.To(organization.Table, organization.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, orgsubscription.OwnerTable, orgsubscription.OwnerColumn), + ) + schemaConfig := os.schemaConfig + step.To.Schema = schemaConfig.Organization + step.Edge.Schema = schemaConfig.OrgSubscription + fromV = sqlgraph.Neighbors(os.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// Hooks returns the client hooks. +func (c *OrgSubscriptionClient) Hooks() []Hook { + hooks := c.hooks.OrgSubscription + return append(hooks[:len(hooks):len(hooks)], orgsubscription.Hooks[:]...) +} + +// Interceptors returns the client interceptors. +func (c *OrgSubscriptionClient) Interceptors() []Interceptor { + inters := c.inters.OrgSubscription + return append(inters[:len(inters):len(inters)], orgsubscription.Interceptors[:]...) +} + +func (c *OrgSubscriptionClient) mutate(ctx context.Context, m *OrgSubscriptionMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&OrgSubscriptionCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&OrgSubscriptionUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&OrgSubscriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&OrgSubscriptionDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("generated: unknown OrgSubscription mutation op: %q", m.Op()) + } +} + +// OrgSubscriptionHistoryClient is a client for the OrgSubscriptionHistory schema. +type OrgSubscriptionHistoryClient struct { + config +} + +// NewOrgSubscriptionHistoryClient returns a client for the OrgSubscriptionHistory from the given config. +func NewOrgSubscriptionHistoryClient(c config) *OrgSubscriptionHistoryClient { + return &OrgSubscriptionHistoryClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `orgsubscriptionhistory.Hooks(f(g(h())))`. +func (c *OrgSubscriptionHistoryClient) Use(hooks ...Hook) { + c.hooks.OrgSubscriptionHistory = append(c.hooks.OrgSubscriptionHistory, hooks...) +} + +// Intercept adds a list of query interceptors to the interceptors stack. +// A call to `Intercept(f, g, h)` equals to `orgsubscriptionhistory.Intercept(f(g(h())))`. +func (c *OrgSubscriptionHistoryClient) Intercept(interceptors ...Interceptor) { + c.inters.OrgSubscriptionHistory = append(c.inters.OrgSubscriptionHistory, interceptors...) +} + +// Create returns a builder for creating a OrgSubscriptionHistory entity. +func (c *OrgSubscriptionHistoryClient) Create() *OrgSubscriptionHistoryCreate { + mutation := newOrgSubscriptionHistoryMutation(c.config, OpCreate) + return &OrgSubscriptionHistoryCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of OrgSubscriptionHistory entities. +func (c *OrgSubscriptionHistoryClient) CreateBulk(builders ...*OrgSubscriptionHistoryCreate) *OrgSubscriptionHistoryCreateBulk { + return &OrgSubscriptionHistoryCreateBulk{config: c.config, builders: builders} +} + +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *OrgSubscriptionHistoryClient) MapCreateBulk(slice any, setFunc func(*OrgSubscriptionHistoryCreate, int)) *OrgSubscriptionHistoryCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &OrgSubscriptionHistoryCreateBulk{err: fmt.Errorf("calling to OrgSubscriptionHistoryClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*OrgSubscriptionHistoryCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &OrgSubscriptionHistoryCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for OrgSubscriptionHistory. +func (c *OrgSubscriptionHistoryClient) Update() *OrgSubscriptionHistoryUpdate { + mutation := newOrgSubscriptionHistoryMutation(c.config, OpUpdate) + return &OrgSubscriptionHistoryUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *OrgSubscriptionHistoryClient) UpdateOne(osh *OrgSubscriptionHistory) *OrgSubscriptionHistoryUpdateOne { + mutation := newOrgSubscriptionHistoryMutation(c.config, OpUpdateOne, withOrgSubscriptionHistory(osh)) + return &OrgSubscriptionHistoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *OrgSubscriptionHistoryClient) UpdateOneID(id string) *OrgSubscriptionHistoryUpdateOne { + mutation := newOrgSubscriptionHistoryMutation(c.config, OpUpdateOne, withOrgSubscriptionHistoryID(id)) + return &OrgSubscriptionHistoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for OrgSubscriptionHistory. +func (c *OrgSubscriptionHistoryClient) Delete() *OrgSubscriptionHistoryDelete { + mutation := newOrgSubscriptionHistoryMutation(c.config, OpDelete) + return &OrgSubscriptionHistoryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *OrgSubscriptionHistoryClient) DeleteOne(osh *OrgSubscriptionHistory) *OrgSubscriptionHistoryDeleteOne { + return c.DeleteOneID(osh.ID) +} + +// DeleteOneID returns a builder for deleting the given entity by its id. +func (c *OrgSubscriptionHistoryClient) DeleteOneID(id string) *OrgSubscriptionHistoryDeleteOne { + builder := c.Delete().Where(orgsubscriptionhistory.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &OrgSubscriptionHistoryDeleteOne{builder} +} + +// Query returns a query builder for OrgSubscriptionHistory. +func (c *OrgSubscriptionHistoryClient) Query() *OrgSubscriptionHistoryQuery { + return &OrgSubscriptionHistoryQuery{ + config: c.config, + ctx: &QueryContext{Type: TypeOrgSubscriptionHistory}, + inters: c.Interceptors(), + } +} + +// Get returns a OrgSubscriptionHistory entity by its id. +func (c *OrgSubscriptionHistoryClient) Get(ctx context.Context, id string) (*OrgSubscriptionHistory, error) { + return c.Query().Where(orgsubscriptionhistory.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *OrgSubscriptionHistoryClient) GetX(ctx context.Context, id string) *OrgSubscriptionHistory { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// Hooks returns the client hooks. +func (c *OrgSubscriptionHistoryClient) Hooks() []Hook { + return c.hooks.OrgSubscriptionHistory +} + +// Interceptors returns the client interceptors. +func (c *OrgSubscriptionHistoryClient) Interceptors() []Interceptor { + return c.inters.OrgSubscriptionHistory +} + +func (c *OrgSubscriptionHistoryClient) mutate(ctx context.Context, m *OrgSubscriptionHistoryMutation) (Value, error) { + switch m.Op() { + case OpCreate: + return (&OrgSubscriptionHistoryCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdate: + return (&OrgSubscriptionHistoryUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpUpdateOne: + return (&OrgSubscriptionHistoryUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx) + case OpDelete, OpDeleteOne: + return (&OrgSubscriptionHistoryDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx) + default: + return nil, fmt.Errorf("generated: unknown OrgSubscriptionHistory mutation op: %q", m.Op()) + } +} + // OrganizationClient is a client for the Organization schema. type OrganizationClient struct { config @@ -11471,6 +11776,25 @@ func (c *OrganizationClient) QueryEntitlements(o *Organization) *EntitlementQuer return query } +// QueryOrgsubscriptions queries the orgsubscriptions edge of a Organization. +func (c *OrganizationClient) QueryOrgsubscriptions(o *Organization) *OrgSubscriptionQuery { + query := (&OrgSubscriptionClient{config: c.config}).Query() + query.path = func(context.Context) (fromV *sql.Selector, _ error) { + id := o.ID + step := sqlgraph.NewStep( + sqlgraph.From(organization.Table, organization.FieldID, id), + sqlgraph.To(orgsubscription.Table, orgsubscription.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, organization.OrgsubscriptionsTable, organization.OrgsubscriptionsColumn), + ) + schemaConfig := o.schemaConfig + step.To.Schema = schemaConfig.OrgSubscription + step.Edge.Schema = schemaConfig.OrgSubscription + fromV = sqlgraph.Neighbors(o.driver.Dialect(), step) + return fromV, nil + } + return query +} + // QueryOrganizationEntitlement queries the organization_entitlement edge of a Organization. func (c *OrganizationClient) QueryOrganizationEntitlement(o *Organization) *EntitlementQuery { query := (&EntitlementClient{config: c.config}).Query() @@ -17913,13 +18237,14 @@ type ( GroupSettingHistory, Hush, HushHistory, Integration, IntegrationHistory, InternalPolicy, InternalPolicyHistory, Invite, Narrative, NarrativeHistory, Note, NoteHistory, OauthProvider, OauthProviderHistory, OhAuthTooToken, - OrgMembership, OrgMembershipHistory, Organization, OrganizationHistory, - OrganizationSetting, OrganizationSettingHistory, PasswordResetToken, - PersonalAccessToken, Procedure, ProcedureHistory, Program, ProgramHistory, - ProgramMembership, ProgramMembershipHistory, Risk, RiskHistory, Standard, - StandardHistory, Subcontrol, SubcontrolHistory, Subscriber, TFASetting, Task, - TaskHistory, Template, TemplateHistory, User, UserHistory, UserSetting, - UserSettingHistory, Webauthn, Webhook, WebhookHistory []ent.Hook + OrgMembership, OrgMembershipHistory, OrgSubscription, OrgSubscriptionHistory, + Organization, OrganizationHistory, OrganizationSetting, + OrganizationSettingHistory, PasswordResetToken, PersonalAccessToken, Procedure, + ProcedureHistory, Program, ProgramHistory, ProgramMembership, + ProgramMembershipHistory, Risk, RiskHistory, Standard, StandardHistory, + Subcontrol, SubcontrolHistory, Subscriber, TFASetting, Task, TaskHistory, + Template, TemplateHistory, User, UserHistory, UserSetting, UserSettingHistory, + Webauthn, Webhook, WebhookHistory []ent.Hook } inters struct { APIToken, ActionPlan, ActionPlanHistory, Contact, ContactHistory, Control, @@ -17932,13 +18257,14 @@ type ( GroupSettingHistory, Hush, HushHistory, Integration, IntegrationHistory, InternalPolicy, InternalPolicyHistory, Invite, Narrative, NarrativeHistory, Note, NoteHistory, OauthProvider, OauthProviderHistory, OhAuthTooToken, - OrgMembership, OrgMembershipHistory, Organization, OrganizationHistory, - OrganizationSetting, OrganizationSettingHistory, PasswordResetToken, - PersonalAccessToken, Procedure, ProcedureHistory, Program, ProgramHistory, - ProgramMembership, ProgramMembershipHistory, Risk, RiskHistory, Standard, - StandardHistory, Subcontrol, SubcontrolHistory, Subscriber, TFASetting, Task, - TaskHistory, Template, TemplateHistory, User, UserHistory, UserSetting, - UserSettingHistory, Webauthn, Webhook, WebhookHistory []ent.Interceptor + OrgMembership, OrgMembershipHistory, OrgSubscription, OrgSubscriptionHistory, + Organization, OrganizationHistory, OrganizationSetting, + OrganizationSettingHistory, PasswordResetToken, PersonalAccessToken, Procedure, + ProcedureHistory, Program, ProgramHistory, ProgramMembership, + ProgramMembershipHistory, Risk, RiskHistory, Standard, StandardHistory, + Subcontrol, SubcontrolHistory, Subscriber, TFASetting, Task, TaskHistory, + Template, TemplateHistory, User, UserHistory, UserSetting, UserSettingHistory, + Webauthn, Webhook, WebhookHistory []ent.Interceptor } ) diff --git a/internal/ent/generated/edge_cleanup.go b/internal/ent/generated/edge_cleanup.go index db954347..a9b9a13e 100644 --- a/internal/ent/generated/edge_cleanup.go +++ b/internal/ent/generated/edge_cleanup.go @@ -28,6 +28,7 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organization" "github.com/theopenlane/core/internal/ent/generated/organizationsetting" "github.com/theopenlane/core/internal/ent/generated/orgmembership" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" "github.com/theopenlane/core/internal/ent/generated/passwordresettoken" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/procedure" @@ -409,6 +410,20 @@ func OrgMembershipHistoryEdgeCleanup(ctx context.Context, id string) error { return nil } +func OrgSubscriptionEdgeCleanup(ctx context.Context, id string) error { + // If a user has access to delete the object, they have access to delete all edges + ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup orgsubscription edge")) + + return nil +} + +func OrgSubscriptionHistoryEdgeCleanup(ctx context.Context, id string) error { + // If a user has access to delete the object, they have access to delete all edges + ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup orgsubscriptionhistory edge")) + + return nil +} + func OrganizationEdgeCleanup(ctx context.Context, id string) error { // If a user has access to delete the object, they have access to delete all edges ctx = privacy.DecisionContext(ctx, privacy.Allowf("cleanup organization edge")) @@ -462,6 +477,13 @@ func OrganizationEdgeCleanup(ctx context.Context, id string) error { } } + if exists, err := FromContext(ctx).OrgSubscription.Query().Where((orgsubscription.HasOwnerWith(organization.ID(id)))).Exist(ctx); err == nil && exists { + if orgsubscriptionCount, err := FromContext(ctx).OrgSubscription.Delete().Where(orgsubscription.HasOwnerWith(organization.ID(id))).Exec(ctx); err != nil { + log.Debug().Err(err).Int("count", orgsubscriptionCount).Msg("deleting orgsubscription") + return err + } + } + if exists, err := FromContext(ctx).Invite.Query().Where((invite.HasOwnerWith(organization.ID(id)))).Exist(ctx); err == nil && exists { if inviteCount, err := FromContext(ctx).Invite.Delete().Where(invite.HasOwnerWith(organization.ID(id))).Exec(ctx); err != nil { log.Debug().Err(err).Int("count", inviteCount).Msg("deleting invite") diff --git a/internal/ent/generated/ent.go b/internal/ent/generated/ent.go index ddcf5b9f..cc9cad99 100644 --- a/internal/ent/generated/ent.go +++ b/internal/ent/generated/ent.go @@ -66,6 +66,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/passwordresettoken" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/procedure" @@ -203,6 +205,8 @@ func checkColumn(table, column string) error { ohauthtootoken.Table: ohauthtootoken.ValidColumn, orgmembership.Table: orgmembership.ValidColumn, orgmembershiphistory.Table: orgmembershiphistory.ValidColumn, + orgsubscription.Table: orgsubscription.ValidColumn, + orgsubscriptionhistory.Table: orgsubscriptionhistory.ValidColumn, organization.Table: organization.ValidColumn, organizationhistory.Table: organizationhistory.ValidColumn, organizationsetting.Table: organizationsetting.ValidColumn, diff --git a/internal/ent/generated/entql.go b/internal/ent/generated/entql.go index 136386f1..9951cce2 100644 --- a/internal/ent/generated/entql.go +++ b/internal/ent/generated/entql.go @@ -57,6 +57,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/passwordresettoken" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/predicate" @@ -94,7 +96,7 @@ import ( // schemaGraph holds a representation of ent/schema at runtime. var schemaGraph = func() *sqlgraph.Schema { - graph := &sqlgraph.Schema{Nodes: make([]*sqlgraph.Node, 81)} + graph := &sqlgraph.Schema{Nodes: make([]*sqlgraph.Node, 83)} graph.Nodes[0] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: apitoken.Table, @@ -1538,6 +1540,69 @@ var schemaGraph = func() *sqlgraph.Schema { }, } graph.Nodes[50] = &sqlgraph.Node{ + NodeSpec: sqlgraph.NodeSpec{ + Table: orgsubscription.Table, + Columns: orgsubscription.Columns, + ID: &sqlgraph.FieldSpec{ + Type: field.TypeString, + Column: orgsubscription.FieldID, + }, + }, + Type: "OrgSubscription", + Fields: map[string]*sqlgraph.FieldSpec{ + orgsubscription.FieldCreatedAt: {Type: field.TypeTime, Column: orgsubscription.FieldCreatedAt}, + orgsubscription.FieldUpdatedAt: {Type: field.TypeTime, Column: orgsubscription.FieldUpdatedAt}, + orgsubscription.FieldCreatedBy: {Type: field.TypeString, Column: orgsubscription.FieldCreatedBy}, + orgsubscription.FieldUpdatedBy: {Type: field.TypeString, Column: orgsubscription.FieldUpdatedBy}, + orgsubscription.FieldMappingID: {Type: field.TypeString, Column: orgsubscription.FieldMappingID}, + orgsubscription.FieldTags: {Type: field.TypeJSON, Column: orgsubscription.FieldTags}, + orgsubscription.FieldDeletedAt: {Type: field.TypeTime, Column: orgsubscription.FieldDeletedAt}, + orgsubscription.FieldDeletedBy: {Type: field.TypeString, Column: orgsubscription.FieldDeletedBy}, + orgsubscription.FieldOwnerID: {Type: field.TypeString, Column: orgsubscription.FieldOwnerID}, + orgsubscription.FieldStripeSubscriptionID: {Type: field.TypeString, Column: orgsubscription.FieldStripeSubscriptionID}, + orgsubscription.FieldProductTier: {Type: field.TypeString, Column: orgsubscription.FieldProductTier}, + orgsubscription.FieldStripeProductTierID: {Type: field.TypeString, Column: orgsubscription.FieldStripeProductTierID}, + orgsubscription.FieldStripeSubscriptionStatus: {Type: field.TypeString, Column: orgsubscription.FieldStripeSubscriptionStatus}, + orgsubscription.FieldActive: {Type: field.TypeBool, Column: orgsubscription.FieldActive}, + orgsubscription.FieldStripeCustomerID: {Type: field.TypeString, Column: orgsubscription.FieldStripeCustomerID}, + orgsubscription.FieldExpiresAt: {Type: field.TypeTime, Column: orgsubscription.FieldExpiresAt}, + orgsubscription.FieldFeatures: {Type: field.TypeJSON, Column: orgsubscription.FieldFeatures}, + }, + } + graph.Nodes[51] = &sqlgraph.Node{ + NodeSpec: sqlgraph.NodeSpec{ + Table: orgsubscriptionhistory.Table, + Columns: orgsubscriptionhistory.Columns, + ID: &sqlgraph.FieldSpec{ + Type: field.TypeString, + Column: orgsubscriptionhistory.FieldID, + }, + }, + Type: "OrgSubscriptionHistory", + Fields: map[string]*sqlgraph.FieldSpec{ + orgsubscriptionhistory.FieldHistoryTime: {Type: field.TypeTime, Column: orgsubscriptionhistory.FieldHistoryTime}, + orgsubscriptionhistory.FieldRef: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldRef}, + orgsubscriptionhistory.FieldOperation: {Type: field.TypeEnum, Column: orgsubscriptionhistory.FieldOperation}, + orgsubscriptionhistory.FieldCreatedAt: {Type: field.TypeTime, Column: orgsubscriptionhistory.FieldCreatedAt}, + orgsubscriptionhistory.FieldUpdatedAt: {Type: field.TypeTime, Column: orgsubscriptionhistory.FieldUpdatedAt}, + orgsubscriptionhistory.FieldCreatedBy: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldCreatedBy}, + orgsubscriptionhistory.FieldUpdatedBy: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldUpdatedBy}, + orgsubscriptionhistory.FieldMappingID: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldMappingID}, + orgsubscriptionhistory.FieldTags: {Type: field.TypeJSON, Column: orgsubscriptionhistory.FieldTags}, + orgsubscriptionhistory.FieldDeletedAt: {Type: field.TypeTime, Column: orgsubscriptionhistory.FieldDeletedAt}, + orgsubscriptionhistory.FieldDeletedBy: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldDeletedBy}, + orgsubscriptionhistory.FieldOwnerID: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldOwnerID}, + orgsubscriptionhistory.FieldStripeSubscriptionID: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldStripeSubscriptionID}, + orgsubscriptionhistory.FieldProductTier: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldProductTier}, + orgsubscriptionhistory.FieldStripeProductTierID: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldStripeProductTierID}, + orgsubscriptionhistory.FieldStripeSubscriptionStatus: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldStripeSubscriptionStatus}, + orgsubscriptionhistory.FieldActive: {Type: field.TypeBool, Column: orgsubscriptionhistory.FieldActive}, + orgsubscriptionhistory.FieldStripeCustomerID: {Type: field.TypeString, Column: orgsubscriptionhistory.FieldStripeCustomerID}, + orgsubscriptionhistory.FieldExpiresAt: {Type: field.TypeTime, Column: orgsubscriptionhistory.FieldExpiresAt}, + orgsubscriptionhistory.FieldFeatures: {Type: field.TypeJSON, Column: orgsubscriptionhistory.FieldFeatures}, + }, + } + graph.Nodes[52] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: organization.Table, Columns: organization.Columns, @@ -1565,7 +1630,7 @@ var schemaGraph = func() *sqlgraph.Schema { organization.FieldDedicatedDb: {Type: field.TypeBool, Column: organization.FieldDedicatedDb}, }, } - graph.Nodes[51] = &sqlgraph.Node{ + graph.Nodes[53] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: organizationhistory.Table, Columns: organizationhistory.Columns, @@ -1596,7 +1661,7 @@ var schemaGraph = func() *sqlgraph.Schema { organizationhistory.FieldDedicatedDb: {Type: field.TypeBool, Column: organizationhistory.FieldDedicatedDb}, }, } - graph.Nodes[52] = &sqlgraph.Node{ + graph.Nodes[54] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: organizationsetting.Table, Columns: organizationsetting.Columns, @@ -1626,7 +1691,7 @@ var schemaGraph = func() *sqlgraph.Schema { organizationsetting.FieldStripeID: {Type: field.TypeString, Column: organizationsetting.FieldStripeID}, }, } - graph.Nodes[53] = &sqlgraph.Node{ + graph.Nodes[55] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: organizationsettinghistory.Table, Columns: organizationsettinghistory.Columns, @@ -1659,7 +1724,7 @@ var schemaGraph = func() *sqlgraph.Schema { organizationsettinghistory.FieldStripeID: {Type: field.TypeString, Column: organizationsettinghistory.FieldStripeID}, }, } - graph.Nodes[54] = &sqlgraph.Node{ + graph.Nodes[56] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: passwordresettoken.Table, Columns: passwordresettoken.Columns, @@ -1684,7 +1749,7 @@ var schemaGraph = func() *sqlgraph.Schema { passwordresettoken.FieldSecret: {Type: field.TypeBytes, Column: passwordresettoken.FieldSecret}, }, } - graph.Nodes[55] = &sqlgraph.Node{ + graph.Nodes[57] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: personalaccesstoken.Table, Columns: personalaccesstoken.Columns, @@ -1712,7 +1777,7 @@ var schemaGraph = func() *sqlgraph.Schema { personalaccesstoken.FieldLastUsedAt: {Type: field.TypeTime, Column: personalaccesstoken.FieldLastUsedAt}, }, } - graph.Nodes[56] = &sqlgraph.Node{ + graph.Nodes[58] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: procedure.Table, Columns: procedure.Columns, @@ -1743,7 +1808,7 @@ var schemaGraph = func() *sqlgraph.Schema { procedure.FieldDetails: {Type: field.TypeJSON, Column: procedure.FieldDetails}, }, } - graph.Nodes[57] = &sqlgraph.Node{ + graph.Nodes[59] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: procedurehistory.Table, Columns: procedurehistory.Columns, @@ -1777,7 +1842,7 @@ var schemaGraph = func() *sqlgraph.Schema { procedurehistory.FieldDetails: {Type: field.TypeJSON, Column: procedurehistory.FieldDetails}, }, } - graph.Nodes[58] = &sqlgraph.Node{ + graph.Nodes[60] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: program.Table, Columns: program.Columns, @@ -1807,7 +1872,7 @@ var schemaGraph = func() *sqlgraph.Schema { program.FieldAuditorReadComments: {Type: field.TypeBool, Column: program.FieldAuditorReadComments}, }, } - graph.Nodes[59] = &sqlgraph.Node{ + graph.Nodes[61] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: programhistory.Table, Columns: programhistory.Columns, @@ -1840,7 +1905,7 @@ var schemaGraph = func() *sqlgraph.Schema { programhistory.FieldAuditorReadComments: {Type: field.TypeBool, Column: programhistory.FieldAuditorReadComments}, }, } - graph.Nodes[60] = &sqlgraph.Node{ + graph.Nodes[62] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: programmembership.Table, Columns: programmembership.Columns, @@ -1863,7 +1928,7 @@ var schemaGraph = func() *sqlgraph.Schema { programmembership.FieldUserID: {Type: field.TypeString, Column: programmembership.FieldUserID}, }, } - graph.Nodes[61] = &sqlgraph.Node{ + graph.Nodes[63] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: programmembershiphistory.Table, Columns: programmembershiphistory.Columns, @@ -1889,7 +1954,7 @@ var schemaGraph = func() *sqlgraph.Schema { programmembershiphistory.FieldUserID: {Type: field.TypeString, Column: programmembershiphistory.FieldUserID}, }, } - graph.Nodes[62] = &sqlgraph.Node{ + graph.Nodes[64] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: risk.Table, Columns: risk.Columns, @@ -1921,7 +1986,7 @@ var schemaGraph = func() *sqlgraph.Schema { risk.FieldDetails: {Type: field.TypeJSON, Column: risk.FieldDetails}, }, } - graph.Nodes[63] = &sqlgraph.Node{ + graph.Nodes[65] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: riskhistory.Table, Columns: riskhistory.Columns, @@ -1956,7 +2021,7 @@ var schemaGraph = func() *sqlgraph.Schema { riskhistory.FieldDetails: {Type: field.TypeJSON, Column: riskhistory.FieldDetails}, }, } - graph.Nodes[64] = &sqlgraph.Node{ + graph.Nodes[66] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: standard.Table, Columns: standard.Columns, @@ -1987,7 +2052,7 @@ var schemaGraph = func() *sqlgraph.Schema { standard.FieldDetails: {Type: field.TypeJSON, Column: standard.FieldDetails}, }, } - graph.Nodes[65] = &sqlgraph.Node{ + graph.Nodes[67] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: standardhistory.Table, Columns: standardhistory.Columns, @@ -2021,7 +2086,7 @@ var schemaGraph = func() *sqlgraph.Schema { standardhistory.FieldDetails: {Type: field.TypeJSON, Column: standardhistory.FieldDetails}, }, } - graph.Nodes[66] = &sqlgraph.Node{ + graph.Nodes[68] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: subcontrol.Table, Columns: subcontrol.Columns, @@ -2059,7 +2124,7 @@ var schemaGraph = func() *sqlgraph.Schema { subcontrol.FieldDetails: {Type: field.TypeJSON, Column: subcontrol.FieldDetails}, }, } - graph.Nodes[67] = &sqlgraph.Node{ + graph.Nodes[69] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: subcontrolhistory.Table, Columns: subcontrolhistory.Columns, @@ -2100,7 +2165,7 @@ var schemaGraph = func() *sqlgraph.Schema { subcontrolhistory.FieldDetails: {Type: field.TypeJSON, Column: subcontrolhistory.FieldDetails}, }, } - graph.Nodes[68] = &sqlgraph.Node{ + graph.Nodes[70] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: subscriber.Table, Columns: subscriber.Columns, @@ -2130,7 +2195,7 @@ var schemaGraph = func() *sqlgraph.Schema { subscriber.FieldSecret: {Type: field.TypeBytes, Column: subscriber.FieldSecret}, }, } - graph.Nodes[69] = &sqlgraph.Node{ + graph.Nodes[71] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: tfasetting.Table, Columns: tfasetting.Columns, @@ -2158,7 +2223,7 @@ var schemaGraph = func() *sqlgraph.Schema { tfasetting.FieldTotpAllowed: {Type: field.TypeBool, Column: tfasetting.FieldTotpAllowed}, }, } - graph.Nodes[70] = &sqlgraph.Node{ + graph.Nodes[72] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: task.Table, Columns: task.Columns, @@ -2185,7 +2250,7 @@ var schemaGraph = func() *sqlgraph.Schema { task.FieldCompleted: {Type: field.TypeTime, Column: task.FieldCompleted}, }, } - graph.Nodes[71] = &sqlgraph.Node{ + graph.Nodes[73] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: taskhistory.Table, Columns: taskhistory.Columns, @@ -2215,7 +2280,7 @@ var schemaGraph = func() *sqlgraph.Schema { taskhistory.FieldCompleted: {Type: field.TypeTime, Column: taskhistory.FieldCompleted}, }, } - graph.Nodes[72] = &sqlgraph.Node{ + graph.Nodes[74] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: template.Table, Columns: template.Columns, @@ -2242,7 +2307,7 @@ var schemaGraph = func() *sqlgraph.Schema { template.FieldUischema: {Type: field.TypeJSON, Column: template.FieldUischema}, }, } - graph.Nodes[73] = &sqlgraph.Node{ + graph.Nodes[75] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: templatehistory.Table, Columns: templatehistory.Columns, @@ -2272,7 +2337,7 @@ var schemaGraph = func() *sqlgraph.Schema { templatehistory.FieldUischema: {Type: field.TypeJSON, Column: templatehistory.FieldUischema}, }, } - graph.Nodes[74] = &sqlgraph.Node{ + graph.Nodes[76] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: user.Table, Columns: user.Columns, @@ -2306,7 +2371,7 @@ var schemaGraph = func() *sqlgraph.Schema { user.FieldRole: {Type: field.TypeEnum, Column: user.FieldRole}, }, } - graph.Nodes[75] = &sqlgraph.Node{ + graph.Nodes[77] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: userhistory.Table, Columns: userhistory.Columns, @@ -2343,7 +2408,7 @@ var schemaGraph = func() *sqlgraph.Schema { userhistory.FieldRole: {Type: field.TypeEnum, Column: userhistory.FieldRole}, }, } - graph.Nodes[76] = &sqlgraph.Node{ + graph.Nodes[78] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: usersetting.Table, Columns: usersetting.Columns, @@ -2373,7 +2438,7 @@ var schemaGraph = func() *sqlgraph.Schema { usersetting.FieldPhoneNumber: {Type: field.TypeString, Column: usersetting.FieldPhoneNumber}, }, } - graph.Nodes[77] = &sqlgraph.Node{ + graph.Nodes[79] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: usersettinghistory.Table, Columns: usersettinghistory.Columns, @@ -2406,7 +2471,7 @@ var schemaGraph = func() *sqlgraph.Schema { usersettinghistory.FieldPhoneNumber: {Type: field.TypeString, Column: usersettinghistory.FieldPhoneNumber}, }, } - graph.Nodes[78] = &sqlgraph.Node{ + graph.Nodes[80] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: webauthn.Table, Columns: webauthn.Columns, @@ -2436,7 +2501,7 @@ var schemaGraph = func() *sqlgraph.Schema { webauthn.FieldUserVerified: {Type: field.TypeBool, Column: webauthn.FieldUserVerified}, }, } - graph.Nodes[79] = &sqlgraph.Node{ + graph.Nodes[81] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: webhook.Table, Columns: webhook.Columns, @@ -2468,7 +2533,7 @@ var schemaGraph = func() *sqlgraph.Schema { webhook.FieldLastResponse: {Type: field.TypeString, Column: webhook.FieldLastResponse}, }, } - graph.Nodes[80] = &sqlgraph.Node{ + graph.Nodes[82] = &sqlgraph.Node{ NodeSpec: sqlgraph.NodeSpec{ Table: webhookhistory.Table, Columns: webhookhistory.Columns, @@ -4555,6 +4620,18 @@ var schemaGraph = func() *sqlgraph.Schema { "OrgMembership", "Event", ) + graph.MustAddE( + "owner", + &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: orgsubscription.OwnerTable, + Columns: []string{orgsubscription.OwnerColumn}, + Bidi: false, + }, + "OrgSubscription", + "Organization", + ) graph.MustAddE( "control_creators", &sqlgraph.EdgeSpec{ @@ -4759,6 +4836,18 @@ var schemaGraph = func() *sqlgraph.Schema { "Organization", "Entitlement", ) + graph.MustAddE( + "orgsubscriptions", + &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: organization.OrgsubscriptionsTable, + Columns: []string{organization.OrgsubscriptionsColumn}, + Bidi: false, + }, + "Organization", + "OrgSubscription", + ) graph.MustAddE( "organization_entitlement", &sqlgraph.EdgeSpec{ @@ -14610,6 +14699,285 @@ func (f *OrgMembershipHistoryFilter) WhereUserID(p entql.StringP) { f.Where(p.Field(orgmembershiphistory.FieldUserID)) } +// addPredicate implements the predicateAdder interface. +func (osq *OrgSubscriptionQuery) addPredicate(pred func(s *sql.Selector)) { + osq.predicates = append(osq.predicates, pred) +} + +// Filter returns a Filter implementation to apply filters on the OrgSubscriptionQuery builder. +func (osq *OrgSubscriptionQuery) Filter() *OrgSubscriptionFilter { + return &OrgSubscriptionFilter{config: osq.config, predicateAdder: osq} +} + +// addPredicate implements the predicateAdder interface. +func (m *OrgSubscriptionMutation) addPredicate(pred func(s *sql.Selector)) { + m.predicates = append(m.predicates, pred) +} + +// Filter returns an entql.Where implementation to apply filters on the OrgSubscriptionMutation builder. +func (m *OrgSubscriptionMutation) Filter() *OrgSubscriptionFilter { + return &OrgSubscriptionFilter{config: m.config, predicateAdder: m} +} + +// OrgSubscriptionFilter provides a generic filtering capability at runtime for OrgSubscriptionQuery. +type OrgSubscriptionFilter struct { + predicateAdder + config +} + +// Where applies the entql predicate on the query filter. +func (f *OrgSubscriptionFilter) Where(p entql.P) { + f.addPredicate(func(s *sql.Selector) { + if err := schemaGraph.EvalP(schemaGraph.Nodes[50].Type, p, s); err != nil { + s.AddError(err) + } + }) +} + +// WhereID applies the entql string predicate on the id field. +func (f *OrgSubscriptionFilter) WhereID(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldID)) +} + +// WhereCreatedAt applies the entql time.Time predicate on the created_at field. +func (f *OrgSubscriptionFilter) WhereCreatedAt(p entql.TimeP) { + f.Where(p.Field(orgsubscription.FieldCreatedAt)) +} + +// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field. +func (f *OrgSubscriptionFilter) WhereUpdatedAt(p entql.TimeP) { + f.Where(p.Field(orgsubscription.FieldUpdatedAt)) +} + +// WhereCreatedBy applies the entql string predicate on the created_by field. +func (f *OrgSubscriptionFilter) WhereCreatedBy(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldCreatedBy)) +} + +// WhereUpdatedBy applies the entql string predicate on the updated_by field. +func (f *OrgSubscriptionFilter) WhereUpdatedBy(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldUpdatedBy)) +} + +// WhereMappingID applies the entql string predicate on the mapping_id field. +func (f *OrgSubscriptionFilter) WhereMappingID(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldMappingID)) +} + +// WhereTags applies the entql json.RawMessage predicate on the tags field. +func (f *OrgSubscriptionFilter) WhereTags(p entql.BytesP) { + f.Where(p.Field(orgsubscription.FieldTags)) +} + +// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field. +func (f *OrgSubscriptionFilter) WhereDeletedAt(p entql.TimeP) { + f.Where(p.Field(orgsubscription.FieldDeletedAt)) +} + +// WhereDeletedBy applies the entql string predicate on the deleted_by field. +func (f *OrgSubscriptionFilter) WhereDeletedBy(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldDeletedBy)) +} + +// WhereOwnerID applies the entql string predicate on the owner_id field. +func (f *OrgSubscriptionFilter) WhereOwnerID(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldOwnerID)) +} + +// WhereStripeSubscriptionID applies the entql string predicate on the stripe_subscription_id field. +func (f *OrgSubscriptionFilter) WhereStripeSubscriptionID(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldStripeSubscriptionID)) +} + +// WhereProductTier applies the entql string predicate on the product_tier field. +func (f *OrgSubscriptionFilter) WhereProductTier(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldProductTier)) +} + +// WhereStripeProductTierID applies the entql string predicate on the stripe_product_tier_id field. +func (f *OrgSubscriptionFilter) WhereStripeProductTierID(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldStripeProductTierID)) +} + +// WhereStripeSubscriptionStatus applies the entql string predicate on the stripe_subscription_status field. +func (f *OrgSubscriptionFilter) WhereStripeSubscriptionStatus(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldStripeSubscriptionStatus)) +} + +// WhereActive applies the entql bool predicate on the active field. +func (f *OrgSubscriptionFilter) WhereActive(p entql.BoolP) { + f.Where(p.Field(orgsubscription.FieldActive)) +} + +// WhereStripeCustomerID applies the entql string predicate on the stripe_customer_id field. +func (f *OrgSubscriptionFilter) WhereStripeCustomerID(p entql.StringP) { + f.Where(p.Field(orgsubscription.FieldStripeCustomerID)) +} + +// WhereExpiresAt applies the entql time.Time predicate on the expires_at field. +func (f *OrgSubscriptionFilter) WhereExpiresAt(p entql.TimeP) { + f.Where(p.Field(orgsubscription.FieldExpiresAt)) +} + +// WhereFeatures applies the entql json.RawMessage predicate on the features field. +func (f *OrgSubscriptionFilter) WhereFeatures(p entql.BytesP) { + f.Where(p.Field(orgsubscription.FieldFeatures)) +} + +// WhereHasOwner applies a predicate to check if query has an edge owner. +func (f *OrgSubscriptionFilter) WhereHasOwner() { + f.Where(entql.HasEdge("owner")) +} + +// WhereHasOwnerWith applies a predicate to check if query has an edge owner with a given conditions (other predicates). +func (f *OrgSubscriptionFilter) WhereHasOwnerWith(preds ...predicate.Organization) { + f.Where(entql.HasEdgeWith("owner", sqlgraph.WrapFunc(func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }))) +} + +// addPredicate implements the predicateAdder interface. +func (oshq *OrgSubscriptionHistoryQuery) addPredicate(pred func(s *sql.Selector)) { + oshq.predicates = append(oshq.predicates, pred) +} + +// Filter returns a Filter implementation to apply filters on the OrgSubscriptionHistoryQuery builder. +func (oshq *OrgSubscriptionHistoryQuery) Filter() *OrgSubscriptionHistoryFilter { + return &OrgSubscriptionHistoryFilter{config: oshq.config, predicateAdder: oshq} +} + +// addPredicate implements the predicateAdder interface. +func (m *OrgSubscriptionHistoryMutation) addPredicate(pred func(s *sql.Selector)) { + m.predicates = append(m.predicates, pred) +} + +// Filter returns an entql.Where implementation to apply filters on the OrgSubscriptionHistoryMutation builder. +func (m *OrgSubscriptionHistoryMutation) Filter() *OrgSubscriptionHistoryFilter { + return &OrgSubscriptionHistoryFilter{config: m.config, predicateAdder: m} +} + +// OrgSubscriptionHistoryFilter provides a generic filtering capability at runtime for OrgSubscriptionHistoryQuery. +type OrgSubscriptionHistoryFilter struct { + predicateAdder + config +} + +// Where applies the entql predicate on the query filter. +func (f *OrgSubscriptionHistoryFilter) Where(p entql.P) { + f.addPredicate(func(s *sql.Selector) { + if err := schemaGraph.EvalP(schemaGraph.Nodes[51].Type, p, s); err != nil { + s.AddError(err) + } + }) +} + +// WhereID applies the entql string predicate on the id field. +func (f *OrgSubscriptionHistoryFilter) WhereID(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldID)) +} + +// WhereHistoryTime applies the entql time.Time predicate on the history_time field. +func (f *OrgSubscriptionHistoryFilter) WhereHistoryTime(p entql.TimeP) { + f.Where(p.Field(orgsubscriptionhistory.FieldHistoryTime)) +} + +// WhereRef applies the entql string predicate on the ref field. +func (f *OrgSubscriptionHistoryFilter) WhereRef(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldRef)) +} + +// WhereOperation applies the entql string predicate on the operation field. +func (f *OrgSubscriptionHistoryFilter) WhereOperation(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldOperation)) +} + +// WhereCreatedAt applies the entql time.Time predicate on the created_at field. +func (f *OrgSubscriptionHistoryFilter) WhereCreatedAt(p entql.TimeP) { + f.Where(p.Field(orgsubscriptionhistory.FieldCreatedAt)) +} + +// WhereUpdatedAt applies the entql time.Time predicate on the updated_at field. +func (f *OrgSubscriptionHistoryFilter) WhereUpdatedAt(p entql.TimeP) { + f.Where(p.Field(orgsubscriptionhistory.FieldUpdatedAt)) +} + +// WhereCreatedBy applies the entql string predicate on the created_by field. +func (f *OrgSubscriptionHistoryFilter) WhereCreatedBy(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldCreatedBy)) +} + +// WhereUpdatedBy applies the entql string predicate on the updated_by field. +func (f *OrgSubscriptionHistoryFilter) WhereUpdatedBy(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldUpdatedBy)) +} + +// WhereMappingID applies the entql string predicate on the mapping_id field. +func (f *OrgSubscriptionHistoryFilter) WhereMappingID(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldMappingID)) +} + +// WhereTags applies the entql json.RawMessage predicate on the tags field. +func (f *OrgSubscriptionHistoryFilter) WhereTags(p entql.BytesP) { + f.Where(p.Field(orgsubscriptionhistory.FieldTags)) +} + +// WhereDeletedAt applies the entql time.Time predicate on the deleted_at field. +func (f *OrgSubscriptionHistoryFilter) WhereDeletedAt(p entql.TimeP) { + f.Where(p.Field(orgsubscriptionhistory.FieldDeletedAt)) +} + +// WhereDeletedBy applies the entql string predicate on the deleted_by field. +func (f *OrgSubscriptionHistoryFilter) WhereDeletedBy(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldDeletedBy)) +} + +// WhereOwnerID applies the entql string predicate on the owner_id field. +func (f *OrgSubscriptionHistoryFilter) WhereOwnerID(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldOwnerID)) +} + +// WhereStripeSubscriptionID applies the entql string predicate on the stripe_subscription_id field. +func (f *OrgSubscriptionHistoryFilter) WhereStripeSubscriptionID(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldStripeSubscriptionID)) +} + +// WhereProductTier applies the entql string predicate on the product_tier field. +func (f *OrgSubscriptionHistoryFilter) WhereProductTier(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldProductTier)) +} + +// WhereStripeProductTierID applies the entql string predicate on the stripe_product_tier_id field. +func (f *OrgSubscriptionHistoryFilter) WhereStripeProductTierID(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldStripeProductTierID)) +} + +// WhereStripeSubscriptionStatus applies the entql string predicate on the stripe_subscription_status field. +func (f *OrgSubscriptionHistoryFilter) WhereStripeSubscriptionStatus(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldStripeSubscriptionStatus)) +} + +// WhereActive applies the entql bool predicate on the active field. +func (f *OrgSubscriptionHistoryFilter) WhereActive(p entql.BoolP) { + f.Where(p.Field(orgsubscriptionhistory.FieldActive)) +} + +// WhereStripeCustomerID applies the entql string predicate on the stripe_customer_id field. +func (f *OrgSubscriptionHistoryFilter) WhereStripeCustomerID(p entql.StringP) { + f.Where(p.Field(orgsubscriptionhistory.FieldStripeCustomerID)) +} + +// WhereExpiresAt applies the entql time.Time predicate on the expires_at field. +func (f *OrgSubscriptionHistoryFilter) WhereExpiresAt(p entql.TimeP) { + f.Where(p.Field(orgsubscriptionhistory.FieldExpiresAt)) +} + +// WhereFeatures applies the entql json.RawMessage predicate on the features field. +func (f *OrgSubscriptionHistoryFilter) WhereFeatures(p entql.BytesP) { + f.Where(p.Field(orgsubscriptionhistory.FieldFeatures)) +} + // addPredicate implements the predicateAdder interface. func (oq *OrganizationQuery) addPredicate(pred func(s *sql.Selector)) { oq.predicates = append(oq.predicates, pred) @@ -14639,7 +15007,7 @@ type OrganizationFilter struct { // Where applies the entql predicate on the query filter. func (f *OrganizationFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[50].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[52].Type, p, s); err != nil { s.AddError(err) } }) @@ -14963,6 +15331,20 @@ func (f *OrganizationFilter) WhereHasEntitlementsWith(preds ...predicate.Entitle }))) } +// WhereHasOrgsubscriptions applies a predicate to check if query has an edge orgsubscriptions. +func (f *OrganizationFilter) WhereHasOrgsubscriptions() { + f.Where(entql.HasEdge("orgsubscriptions")) +} + +// WhereHasOrgsubscriptionsWith applies a predicate to check if query has an edge orgsubscriptions with a given conditions (other predicates). +func (f *OrganizationFilter) WhereHasOrgsubscriptionsWith(preds ...predicate.OrgSubscription) { + f.Where(entql.HasEdgeWith("orgsubscriptions", sqlgraph.WrapFunc(func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }))) +} + // WhereHasOrganizationEntitlement applies a predicate to check if query has an edge organization_entitlement. func (f *OrganizationFilter) WhereHasOrganizationEntitlement() { f.Where(entql.HasEdge("organization_entitlement")) @@ -15384,7 +15766,7 @@ type OrganizationHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *OrganizationHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[51].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[53].Type, p, s); err != nil { s.AddError(err) } }) @@ -15514,7 +15896,7 @@ type OrganizationSettingFilter struct { // Where applies the entql predicate on the query filter. func (f *OrganizationSettingFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[52].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[54].Type, p, s); err != nil { s.AddError(err) } }) @@ -15667,7 +16049,7 @@ type OrganizationSettingHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *OrganizationSettingHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[53].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[55].Type, p, s); err != nil { s.AddError(err) } }) @@ -15807,7 +16189,7 @@ type PasswordResetTokenFilter struct { // Where applies the entql predicate on the query filter. func (f *PasswordResetTokenFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[54].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[56].Type, p, s); err != nil { s.AddError(err) } }) @@ -15921,7 +16303,7 @@ type PersonalAccessTokenFilter struct { // Where applies the entql predicate on the query filter. func (f *PersonalAccessTokenFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[55].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[57].Type, p, s); err != nil { s.AddError(err) } }) @@ -16078,7 +16460,7 @@ type ProcedureFilter struct { // Where applies the entql predicate on the query filter. func (f *ProcedureFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[56].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[58].Type, p, s); err != nil { s.AddError(err) } }) @@ -16334,7 +16716,7 @@ type ProcedureHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *ProcedureHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[57].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[59].Type, p, s); err != nil { s.AddError(err) } }) @@ -16479,7 +16861,7 @@ type ProgramFilter struct { // Where applies the entql predicate on the query filter. func (f *ProgramFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[58].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[60].Type, p, s); err != nil { s.AddError(err) } }) @@ -16856,7 +17238,7 @@ type ProgramHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *ProgramHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[59].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[61].Type, p, s); err != nil { s.AddError(err) } }) @@ -16996,7 +17378,7 @@ type ProgramMembershipFilter struct { // Where applies the entql predicate on the query filter. func (f *ProgramMembershipFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[60].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[62].Type, p, s); err != nil { s.AddError(err) } }) @@ -17114,7 +17496,7 @@ type ProgramMembershipHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *ProgramMembershipHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[61].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[63].Type, p, s); err != nil { s.AddError(err) } }) @@ -17219,7 +17601,7 @@ type RiskFilter struct { // Where applies the entql predicate on the query filter. func (f *RiskFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[62].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[64].Type, p, s); err != nil { s.AddError(err) } }) @@ -17466,7 +17848,7 @@ type RiskHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *RiskHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[63].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[65].Type, p, s); err != nil { s.AddError(err) } }) @@ -17616,7 +17998,7 @@ type StandardFilter struct { // Where applies the entql predicate on the query filter. func (f *StandardFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[64].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[66].Type, p, s); err != nil { s.AddError(err) } }) @@ -17816,7 +18198,7 @@ type StandardHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *StandardHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[65].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[67].Type, p, s); err != nil { s.AddError(err) } }) @@ -17961,7 +18343,7 @@ type SubcontrolFilter struct { // Where applies the entql predicate on the query filter. func (f *SubcontrolFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[66].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[68].Type, p, s); err != nil { s.AddError(err) } }) @@ -18210,7 +18592,7 @@ type SubcontrolHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *SubcontrolHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[67].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[69].Type, p, s); err != nil { s.AddError(err) } }) @@ -18390,7 +18772,7 @@ type SubscriberFilter struct { // Where applies the entql predicate on the query filter. func (f *SubscriberFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[68].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[70].Type, p, s); err != nil { s.AddError(err) } }) @@ -18543,7 +18925,7 @@ type TFASettingFilter struct { // Where applies the entql predicate on the query filter. func (f *TFASettingFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[69].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[71].Type, p, s); err != nil { s.AddError(err) } }) @@ -18672,7 +19054,7 @@ type TaskFilter struct { // Where applies the entql predicate on the query filter. func (f *TaskFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[70].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[72].Type, p, s); err != nil { s.AddError(err) } }) @@ -18922,7 +19304,7 @@ type TaskHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *TaskHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[71].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[73].Type, p, s); err != nil { s.AddError(err) } }) @@ -19047,7 +19429,7 @@ type TemplateFilter struct { // Where applies the entql predicate on the query filter. func (f *TemplateFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[72].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[74].Type, p, s); err != nil { s.AddError(err) } }) @@ -19199,7 +19581,7 @@ type TemplateHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *TemplateHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[73].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[75].Type, p, s); err != nil { s.AddError(err) } }) @@ -19324,7 +19706,7 @@ type UserFilter struct { // Where applies the entql predicate on the query filter. func (f *UserFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[74].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[76].Type, p, s); err != nil { s.AddError(err) } }) @@ -19735,7 +20117,7 @@ type UserHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *UserHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[75].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[77].Type, p, s); err != nil { s.AddError(err) } }) @@ -19895,7 +20277,7 @@ type UserSettingFilter struct { // Where applies the entql predicate on the query filter. func (f *UserSettingFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[76].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[78].Type, p, s); err != nil { s.AddError(err) } }) @@ -20062,7 +20444,7 @@ type UserSettingHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *UserSettingHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[77].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[79].Type, p, s); err != nil { s.AddError(err) } }) @@ -20202,7 +20584,7 @@ type WebauthnFilter struct { // Where applies the entql predicate on the query filter. func (f *WebauthnFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[78].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[80].Type, p, s); err != nil { s.AddError(err) } }) @@ -20341,7 +20723,7 @@ type WebhookFilter struct { // Where applies the entql predicate on the query filter. func (f *WebhookFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[79].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[81].Type, p, s); err != nil { s.AddError(err) } }) @@ -20518,7 +20900,7 @@ type WebhookHistoryFilter struct { // Where applies the entql predicate on the query filter. func (f *WebhookHistoryFilter) Where(p entql.P) { f.addPredicate(func(s *sql.Selector) { - if err := schemaGraph.EvalP(schemaGraph.Nodes[80].Type, p, s); err != nil { + if err := schemaGraph.EvalP(schemaGraph.Nodes[82].Type, p, s); err != nil { s.AddError(err) } }) diff --git a/internal/ent/generated/gql_collection.go b/internal/ent/generated/gql_collection.go index 8f969e8c..2090ce72 100644 --- a/internal/ent/generated/gql_collection.go +++ b/internal/ent/generated/gql_collection.go @@ -63,6 +63,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/procedure" "github.com/theopenlane/core/internal/ent/generated/procedurehistory" @@ -9237,6 +9239,320 @@ func newOrgMembershipHistoryPaginateArgs(rv map[string]any) *orgmembershiphistor return args } +// CollectFields tells the query-builder to eagerly load connected nodes by resolver context. +func (os *OrgSubscriptionQuery) CollectFields(ctx context.Context, satisfies ...string) (*OrgSubscriptionQuery, error) { + fc := graphql.GetFieldContext(ctx) + if fc == nil { + return os, nil + } + if err := os.collectField(ctx, false, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil { + return nil, err + } + return os, nil +} + +func (os *OrgSubscriptionQuery) collectField(ctx context.Context, oneNode bool, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error { + path = append([]string(nil), path...) + var ( + unknownSeen bool + fieldSeen = make(map[string]struct{}, len(orgsubscription.Columns)) + selectedFields = []string{orgsubscription.FieldID} + ) + for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) { + switch field.Name { + + case "owner": + var ( + alias = field.Alias + path = append(path, alias) + query = (&OrganizationClient{config: os.config}).Query() + ) + if err := query.collectField(ctx, oneNode, opCtx, field, path, mayAddCondition(satisfies, organizationImplementors)...); err != nil { + return err + } + os.withOwner = query + if _, ok := fieldSeen[orgsubscription.FieldOwnerID]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldOwnerID) + fieldSeen[orgsubscription.FieldOwnerID] = struct{}{} + } + case "createdAt": + if _, ok := fieldSeen[orgsubscription.FieldCreatedAt]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldCreatedAt) + fieldSeen[orgsubscription.FieldCreatedAt] = struct{}{} + } + case "updatedAt": + if _, ok := fieldSeen[orgsubscription.FieldUpdatedAt]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldUpdatedAt) + fieldSeen[orgsubscription.FieldUpdatedAt] = struct{}{} + } + case "createdBy": + if _, ok := fieldSeen[orgsubscription.FieldCreatedBy]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldCreatedBy) + fieldSeen[orgsubscription.FieldCreatedBy] = struct{}{} + } + case "updatedBy": + if _, ok := fieldSeen[orgsubscription.FieldUpdatedBy]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldUpdatedBy) + fieldSeen[orgsubscription.FieldUpdatedBy] = struct{}{} + } + case "tags": + if _, ok := fieldSeen[orgsubscription.FieldTags]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldTags) + fieldSeen[orgsubscription.FieldTags] = struct{}{} + } + case "deletedAt": + if _, ok := fieldSeen[orgsubscription.FieldDeletedAt]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldDeletedAt) + fieldSeen[orgsubscription.FieldDeletedAt] = struct{}{} + } + case "deletedBy": + if _, ok := fieldSeen[orgsubscription.FieldDeletedBy]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldDeletedBy) + fieldSeen[orgsubscription.FieldDeletedBy] = struct{}{} + } + case "ownerID": + if _, ok := fieldSeen[orgsubscription.FieldOwnerID]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldOwnerID) + fieldSeen[orgsubscription.FieldOwnerID] = struct{}{} + } + case "stripeSubscriptionID": + if _, ok := fieldSeen[orgsubscription.FieldStripeSubscriptionID]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldStripeSubscriptionID) + fieldSeen[orgsubscription.FieldStripeSubscriptionID] = struct{}{} + } + case "productTier": + if _, ok := fieldSeen[orgsubscription.FieldProductTier]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldProductTier) + fieldSeen[orgsubscription.FieldProductTier] = struct{}{} + } + case "stripeProductTierID": + if _, ok := fieldSeen[orgsubscription.FieldStripeProductTierID]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldStripeProductTierID) + fieldSeen[orgsubscription.FieldStripeProductTierID] = struct{}{} + } + case "stripeSubscriptionStatus": + if _, ok := fieldSeen[orgsubscription.FieldStripeSubscriptionStatus]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldStripeSubscriptionStatus) + fieldSeen[orgsubscription.FieldStripeSubscriptionStatus] = struct{}{} + } + case "active": + if _, ok := fieldSeen[orgsubscription.FieldActive]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldActive) + fieldSeen[orgsubscription.FieldActive] = struct{}{} + } + case "stripeCustomerID": + if _, ok := fieldSeen[orgsubscription.FieldStripeCustomerID]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldStripeCustomerID) + fieldSeen[orgsubscription.FieldStripeCustomerID] = struct{}{} + } + case "expiresAt": + if _, ok := fieldSeen[orgsubscription.FieldExpiresAt]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldExpiresAt) + fieldSeen[orgsubscription.FieldExpiresAt] = struct{}{} + } + case "features": + if _, ok := fieldSeen[orgsubscription.FieldFeatures]; !ok { + selectedFields = append(selectedFields, orgsubscription.FieldFeatures) + fieldSeen[orgsubscription.FieldFeatures] = struct{}{} + } + case "id": + case "__typename": + default: + unknownSeen = true + } + } + if !unknownSeen { + os.Select(selectedFields...) + } + return nil +} + +type orgsubscriptionPaginateArgs struct { + first, last *int + after, before *Cursor + opts []OrgSubscriptionPaginateOption +} + +func newOrgSubscriptionPaginateArgs(rv map[string]any) *orgsubscriptionPaginateArgs { + args := &orgsubscriptionPaginateArgs{} + if rv == nil { + return args + } + if v := rv[firstField]; v != nil { + args.first = v.(*int) + } + if v := rv[lastField]; v != nil { + args.last = v.(*int) + } + if v := rv[afterField]; v != nil { + args.after = v.(*Cursor) + } + if v := rv[beforeField]; v != nil { + args.before = v.(*Cursor) + } + if v, ok := rv[whereField].(*OrgSubscriptionWhereInput); ok { + args.opts = append(args.opts, WithOrgSubscriptionFilter(v.Filter)) + } + return args +} + +// CollectFields tells the query-builder to eagerly load connected nodes by resolver context. +func (osh *OrgSubscriptionHistoryQuery) CollectFields(ctx context.Context, satisfies ...string) (*OrgSubscriptionHistoryQuery, error) { + fc := graphql.GetFieldContext(ctx) + if fc == nil { + return osh, nil + } + if err := osh.collectField(ctx, false, graphql.GetOperationContext(ctx), fc.Field, nil, satisfies...); err != nil { + return nil, err + } + return osh, nil +} + +func (osh *OrgSubscriptionHistoryQuery) collectField(ctx context.Context, oneNode bool, opCtx *graphql.OperationContext, collected graphql.CollectedField, path []string, satisfies ...string) error { + path = append([]string(nil), path...) + var ( + unknownSeen bool + fieldSeen = make(map[string]struct{}, len(orgsubscriptionhistory.Columns)) + selectedFields = []string{orgsubscriptionhistory.FieldID} + ) + for _, field := range graphql.CollectFields(opCtx, collected.Selections, satisfies) { + switch field.Name { + case "historyTime": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldHistoryTime]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldHistoryTime) + fieldSeen[orgsubscriptionhistory.FieldHistoryTime] = struct{}{} + } + case "ref": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldRef]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldRef) + fieldSeen[orgsubscriptionhistory.FieldRef] = struct{}{} + } + case "operation": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldOperation]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldOperation) + fieldSeen[orgsubscriptionhistory.FieldOperation] = struct{}{} + } + case "createdAt": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldCreatedAt]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldCreatedAt) + fieldSeen[orgsubscriptionhistory.FieldCreatedAt] = struct{}{} + } + case "updatedAt": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldUpdatedAt]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldUpdatedAt) + fieldSeen[orgsubscriptionhistory.FieldUpdatedAt] = struct{}{} + } + case "createdBy": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldCreatedBy]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldCreatedBy) + fieldSeen[orgsubscriptionhistory.FieldCreatedBy] = struct{}{} + } + case "updatedBy": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldUpdatedBy]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldUpdatedBy) + fieldSeen[orgsubscriptionhistory.FieldUpdatedBy] = struct{}{} + } + case "tags": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldTags]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldTags) + fieldSeen[orgsubscriptionhistory.FieldTags] = struct{}{} + } + case "deletedAt": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldDeletedAt]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldDeletedAt) + fieldSeen[orgsubscriptionhistory.FieldDeletedAt] = struct{}{} + } + case "deletedBy": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldDeletedBy]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldDeletedBy) + fieldSeen[orgsubscriptionhistory.FieldDeletedBy] = struct{}{} + } + case "ownerID": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldOwnerID]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldOwnerID) + fieldSeen[orgsubscriptionhistory.FieldOwnerID] = struct{}{} + } + case "stripeSubscriptionID": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldStripeSubscriptionID]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldStripeSubscriptionID) + fieldSeen[orgsubscriptionhistory.FieldStripeSubscriptionID] = struct{}{} + } + case "productTier": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldProductTier]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldProductTier) + fieldSeen[orgsubscriptionhistory.FieldProductTier] = struct{}{} + } + case "stripeProductTierID": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldStripeProductTierID]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldStripeProductTierID) + fieldSeen[orgsubscriptionhistory.FieldStripeProductTierID] = struct{}{} + } + case "stripeSubscriptionStatus": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldStripeSubscriptionStatus]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldStripeSubscriptionStatus) + fieldSeen[orgsubscriptionhistory.FieldStripeSubscriptionStatus] = struct{}{} + } + case "active": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldActive]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldActive) + fieldSeen[orgsubscriptionhistory.FieldActive] = struct{}{} + } + case "stripeCustomerID": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldStripeCustomerID]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldStripeCustomerID) + fieldSeen[orgsubscriptionhistory.FieldStripeCustomerID] = struct{}{} + } + case "expiresAt": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldExpiresAt]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldExpiresAt) + fieldSeen[orgsubscriptionhistory.FieldExpiresAt] = struct{}{} + } + case "features": + if _, ok := fieldSeen[orgsubscriptionhistory.FieldFeatures]; !ok { + selectedFields = append(selectedFields, orgsubscriptionhistory.FieldFeatures) + fieldSeen[orgsubscriptionhistory.FieldFeatures] = struct{}{} + } + case "id": + case "__typename": + default: + unknownSeen = true + } + } + if !unknownSeen { + osh.Select(selectedFields...) + } + return nil +} + +type orgsubscriptionhistoryPaginateArgs struct { + first, last *int + after, before *Cursor + opts []OrgSubscriptionHistoryPaginateOption +} + +func newOrgSubscriptionHistoryPaginateArgs(rv map[string]any) *orgsubscriptionhistoryPaginateArgs { + args := &orgsubscriptionhistoryPaginateArgs{} + if rv == nil { + return args + } + if v := rv[firstField]; v != nil { + args.first = v.(*int) + } + if v := rv[lastField]; v != nil { + args.last = v.(*int) + } + if v := rv[afterField]; v != nil { + args.after = v.(*Cursor) + } + if v := rv[beforeField]; v != nil { + args.before = v.(*Cursor) + } + if v, ok := rv[whereField].(*OrgSubscriptionHistoryWhereInput); ok { + args.opts = append(args.opts, WithOrgSubscriptionHistoryFilter(v.Filter)) + } + return args +} + // CollectFields tells the query-builder to eagerly load connected nodes by resolver context. func (o *OrganizationQuery) CollectFields(ctx context.Context, satisfies ...string) (*OrganizationQuery, error) { fc := graphql.GetFieldContext(ctx) @@ -9556,6 +9872,19 @@ func (o *OrganizationQuery) collectField(ctx context.Context, oneNode bool, opCt *wq = *query }) + case "orgsubscriptions": + var ( + alias = field.Alias + path = append(path, alias) + query = (&OrgSubscriptionClient{config: o.config}).Query() + ) + if err := query.collectField(ctx, false, opCtx, field, path, mayAddCondition(satisfies, orgsubscriptionImplementors)...); err != nil { + return err + } + o.WithNamedOrgsubscriptions(alias, func(wq *OrgSubscriptionQuery) { + *wq = *query + }) + case "organizationEntitlement": var ( alias = field.Alias diff --git a/internal/ent/generated/gql_edge.go b/internal/ent/generated/gql_edge.go index 6069eaa0..a9da344f 100644 --- a/internal/ent/generated/gql_edge.go +++ b/internal/ent/generated/gql_edge.go @@ -1924,6 +1924,14 @@ func (om *OrgMembership) Events(ctx context.Context) (result []*Event, err error return result, err } +func (os *OrgSubscription) Owner(ctx context.Context) (*Organization, error) { + result, err := os.Edges.OwnerOrErr() + if IsNotLoaded(err) { + result, err = os.QueryOwner().Only(ctx) + } + return result, MaskNotFound(err) +} + func (o *Organization) ControlCreators(ctx context.Context) (result []*Group, err error) { if fc := graphql.GetFieldContext(ctx); fc != nil && fc.Field.Alias != "" { result, err = o.NamedControlCreators(graphql.GetFieldContext(ctx).Field.Alias) @@ -2129,6 +2137,18 @@ func (o *Organization) Entitlements(ctx context.Context) (result []*Entitlement, return result, err } +func (o *Organization) Orgsubscriptions(ctx context.Context) (result []*OrgSubscription, err error) { + if fc := graphql.GetFieldContext(ctx); fc != nil && fc.Field.Alias != "" { + result, err = o.NamedOrgsubscriptions(graphql.GetFieldContext(ctx).Field.Alias) + } else { + result, err = o.Edges.OrgsubscriptionsOrErr() + } + if IsNotLoaded(err) { + result, err = o.QueryOrgsubscriptions().All(ctx) + } + return result, err +} + func (o *Organization) OrganizationEntitlement(ctx context.Context) (result []*Entitlement, err error) { if fc := graphql.GetFieldContext(ctx); fc != nil && fc.Field.Alias != "" { result, err = o.NamedOrganizationEntitlement(graphql.GetFieldContext(ctx).Field.Alias) diff --git a/internal/ent/generated/gql_mutation_input.go b/internal/ent/generated/gql_mutation_input.go index 2d0dcec4..f1fa53f0 100644 --- a/internal/ent/generated/gql_mutation_input.go +++ b/internal/ent/generated/gql_mutation_input.go @@ -5101,6 +5101,164 @@ func (c *OrgMembershipUpdateOne) SetInput(i UpdateOrgMembershipInput) *OrgMember return c } +// CreateOrgSubscriptionInput represents a mutation input for creating orgsubscriptions. +type CreateOrgSubscriptionInput struct { + Tags []string + StripeSubscriptionID *string + ProductTier *string + StripeProductTierID *string + StripeSubscriptionStatus *string + Active *bool + StripeCustomerID *string + ExpiresAt *time.Time + Features []string + OwnerID *string +} + +// Mutate applies the CreateOrgSubscriptionInput on the OrgSubscriptionMutation builder. +func (i *CreateOrgSubscriptionInput) Mutate(m *OrgSubscriptionMutation) { + if v := i.Tags; v != nil { + m.SetTags(v) + } + if v := i.StripeSubscriptionID; v != nil { + m.SetStripeSubscriptionID(*v) + } + if v := i.ProductTier; v != nil { + m.SetProductTier(*v) + } + if v := i.StripeProductTierID; v != nil { + m.SetStripeProductTierID(*v) + } + if v := i.StripeSubscriptionStatus; v != nil { + m.SetStripeSubscriptionStatus(*v) + } + if v := i.Active; v != nil { + m.SetActive(*v) + } + if v := i.StripeCustomerID; v != nil { + m.SetStripeCustomerID(*v) + } + if v := i.ExpiresAt; v != nil { + m.SetExpiresAt(*v) + } + if v := i.Features; v != nil { + m.SetFeatures(v) + } + if v := i.OwnerID; v != nil { + m.SetOwnerID(*v) + } +} + +// SetInput applies the change-set in the CreateOrgSubscriptionInput on the OrgSubscriptionCreate builder. +func (c *OrgSubscriptionCreate) SetInput(i CreateOrgSubscriptionInput) *OrgSubscriptionCreate { + i.Mutate(c.Mutation()) + return c +} + +// UpdateOrgSubscriptionInput represents a mutation input for updating orgsubscriptions. +type UpdateOrgSubscriptionInput struct { + ClearTags bool + Tags []string + AppendTags []string + ClearStripeSubscriptionID bool + StripeSubscriptionID *string + ClearProductTier bool + ProductTier *string + ClearStripeProductTierID bool + StripeProductTierID *string + ClearStripeSubscriptionStatus bool + StripeSubscriptionStatus *string + Active *bool + ClearStripeCustomerID bool + StripeCustomerID *string + ClearExpiresAt bool + ExpiresAt *time.Time + ClearFeatures bool + Features []string + AppendFeatures []string + ClearOwner bool + OwnerID *string +} + +// Mutate applies the UpdateOrgSubscriptionInput on the OrgSubscriptionMutation builder. +func (i *UpdateOrgSubscriptionInput) Mutate(m *OrgSubscriptionMutation) { + if i.ClearTags { + m.ClearTags() + } + if v := i.Tags; v != nil { + m.SetTags(v) + } + if i.AppendTags != nil { + m.AppendTags(i.Tags) + } + if i.ClearStripeSubscriptionID { + m.ClearStripeSubscriptionID() + } + if v := i.StripeSubscriptionID; v != nil { + m.SetStripeSubscriptionID(*v) + } + if i.ClearProductTier { + m.ClearProductTier() + } + if v := i.ProductTier; v != nil { + m.SetProductTier(*v) + } + if i.ClearStripeProductTierID { + m.ClearStripeProductTierID() + } + if v := i.StripeProductTierID; v != nil { + m.SetStripeProductTierID(*v) + } + if i.ClearStripeSubscriptionStatus { + m.ClearStripeSubscriptionStatus() + } + if v := i.StripeSubscriptionStatus; v != nil { + m.SetStripeSubscriptionStatus(*v) + } + if v := i.Active; v != nil { + m.SetActive(*v) + } + if i.ClearStripeCustomerID { + m.ClearStripeCustomerID() + } + if v := i.StripeCustomerID; v != nil { + m.SetStripeCustomerID(*v) + } + if i.ClearExpiresAt { + m.ClearExpiresAt() + } + if v := i.ExpiresAt; v != nil { + m.SetExpiresAt(*v) + } + if i.ClearFeatures { + m.ClearFeatures() + } + if v := i.Features; v != nil { + m.SetFeatures(v) + } + if i.AppendFeatures != nil { + m.AppendFeatures(i.Features) + } + if i.ClearOwner { + m.ClearOwner() + } + if v := i.OwnerID; v != nil { + m.SetOwnerID(*v) + } +} + +// SetInput applies the change-set in the UpdateOrgSubscriptionInput on the OrgSubscriptionUpdate builder. +func (c *OrgSubscriptionUpdate) SetInput(i UpdateOrgSubscriptionInput) *OrgSubscriptionUpdate { + i.Mutate(c.Mutation()) + return c +} + +// SetInput applies the change-set in the UpdateOrgSubscriptionInput on the OrgSubscriptionUpdateOne builder. +func (c *OrgSubscriptionUpdateOne) SetInput(i UpdateOrgSubscriptionInput) *OrgSubscriptionUpdateOne { + i.Mutate(c.Mutation()) + return c +} + // CreateOrganizationInput represents a mutation input for creating organizations. type CreateOrganizationInput struct { Tags []string @@ -5126,6 +5284,7 @@ type CreateOrganizationInput struct { SettingID *string DocumentdatumIDs []string EntitlementIDs []string + OrgsubscriptionIDs []string OrganizationEntitlementIDs []string PersonalAccessTokenIDs []string APITokenIDs []string @@ -5223,6 +5382,9 @@ func (i *CreateOrganizationInput) Mutate(m *OrganizationMutation) { if v := i.EntitlementIDs; len(v) > 0 { m.AddEntitlementIDs(v...) } + if v := i.OrgsubscriptionIDs; len(v) > 0 { + m.AddOrgsubscriptionIDs(v...) + } if v := i.OrganizationEntitlementIDs; len(v) > 0 { m.AddOrganizationEntitlementIDs(v...) } @@ -5364,6 +5526,9 @@ type UpdateOrganizationInput struct { ClearEntitlements bool AddEntitlementIDs []string RemoveEntitlementIDs []string + ClearOrgsubscriptions bool + AddOrgsubscriptionIDs []string + RemoveOrgsubscriptionIDs []string ClearOrganizationEntitlement bool AddOrganizationEntitlementIDs []string RemoveOrganizationEntitlementIDs []string @@ -5605,6 +5770,15 @@ func (i *UpdateOrganizationInput) Mutate(m *OrganizationMutation) { if v := i.RemoveEntitlementIDs; len(v) > 0 { m.RemoveEntitlementIDs(v...) } + if i.ClearOrgsubscriptions { + m.ClearOrgsubscriptions() + } + if v := i.AddOrgsubscriptionIDs; len(v) > 0 { + m.AddOrgsubscriptionIDs(v...) + } + if v := i.RemoveOrgsubscriptionIDs; len(v) > 0 { + m.RemoveOrgsubscriptionIDs(v...) + } if i.ClearOrganizationEntitlement { m.ClearOrganizationEntitlement() } diff --git a/internal/ent/generated/gql_node.go b/internal/ent/generated/gql_node.go index 21e78f18..cfb624bf 100644 --- a/internal/ent/generated/gql_node.go +++ b/internal/ent/generated/gql_node.go @@ -62,6 +62,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/procedure" "github.com/theopenlane/core/internal/ent/generated/procedurehistory" @@ -339,6 +341,16 @@ var orgmembershiphistoryImplementors = []string{"OrgMembershipHistory", "Node"} // IsNode implements the Node interface check for GQLGen. func (*OrgMembershipHistory) IsNode() {} +var orgsubscriptionImplementors = []string{"OrgSubscription", "Node"} + +// IsNode implements the Node interface check for GQLGen. +func (*OrgSubscription) IsNode() {} + +var orgsubscriptionhistoryImplementors = []string{"OrgSubscriptionHistory", "Node"} + +// IsNode implements the Node interface check for GQLGen. +func (*OrgSubscriptionHistory) IsNode() {} + var organizationImplementors = []string{"Organization", "Node"} // IsNode implements the Node interface check for GQLGen. @@ -983,6 +995,24 @@ func (c *Client) noder(ctx context.Context, table string, id string) (Noder, err } } return query.Only(ctx) + case orgsubscription.Table: + query := c.OrgSubscription.Query(). + Where(orgsubscription.ID(id)) + if fc := graphql.GetFieldContext(ctx); fc != nil { + if err := query.collectField(ctx, true, graphql.GetOperationContext(ctx), fc.Field, nil, orgsubscriptionImplementors...); err != nil { + return nil, err + } + } + return query.Only(ctx) + case orgsubscriptionhistory.Table: + query := c.OrgSubscriptionHistory.Query(). + Where(orgsubscriptionhistory.ID(id)) + if fc := graphql.GetFieldContext(ctx); fc != nil { + if err := query.collectField(ctx, true, graphql.GetOperationContext(ctx), fc.Field, nil, orgsubscriptionhistoryImplementors...); err != nil { + return nil, err + } + } + return query.Only(ctx) case organization.Table: query := c.Organization.Query(). Where(organization.ID(id)) @@ -2101,6 +2131,38 @@ func (c *Client) noders(ctx context.Context, table string, ids []string) ([]Node *noder = node } } + case orgsubscription.Table: + query := c.OrgSubscription.Query(). + Where(orgsubscription.IDIn(ids...)) + query, err := query.CollectFields(ctx, orgsubscriptionImplementors...) + if err != nil { + return nil, err + } + nodes, err := query.All(ctx) + if err != nil { + return nil, err + } + for _, node := range nodes { + for _, noder := range idmap[node.ID] { + *noder = node + } + } + case orgsubscriptionhistory.Table: + query := c.OrgSubscriptionHistory.Query(). + Where(orgsubscriptionhistory.IDIn(ids...)) + query, err := query.CollectFields(ctx, orgsubscriptionhistoryImplementors...) + if err != nil { + return nil, err + } + nodes, err := query.All(ctx) + if err != nil { + return nil, err + } + for _, node := range nodes { + for _, noder := range idmap[node.ID] { + *noder = node + } + } case organization.Table: query := c.Organization.Query(). Where(organization.IDIn(ids...)) diff --git a/internal/ent/generated/gql_pagination.go b/internal/ent/generated/gql_pagination.go index 0ec68722..03005695 100644 --- a/internal/ent/generated/gql_pagination.go +++ b/internal/ent/generated/gql_pagination.go @@ -67,6 +67,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/procedure" "github.com/theopenlane/core/internal/ent/generated/procedurehistory" @@ -12990,6 +12992,504 @@ func (omh *OrgMembershipHistory) ToEdge(order *OrgMembershipHistoryOrder) *OrgMe } } +// OrgSubscriptionEdge is the edge representation of OrgSubscription. +type OrgSubscriptionEdge struct { + Node *OrgSubscription `json:"node"` + Cursor Cursor `json:"cursor"` +} + +// OrgSubscriptionConnection is the connection containing edges to OrgSubscription. +type OrgSubscriptionConnection struct { + Edges []*OrgSubscriptionEdge `json:"edges"` + PageInfo PageInfo `json:"pageInfo"` + TotalCount int `json:"totalCount"` +} + +func (c *OrgSubscriptionConnection) build(nodes []*OrgSubscription, pager *orgsubscriptionPager, after *Cursor, first *int, before *Cursor, last *int) { + c.PageInfo.HasNextPage = before != nil + c.PageInfo.HasPreviousPage = after != nil + if first != nil && *first+1 == len(nodes) { + c.PageInfo.HasNextPage = true + nodes = nodes[:len(nodes)-1] + } else if last != nil && *last+1 == len(nodes) { + c.PageInfo.HasPreviousPage = true + nodes = nodes[:len(nodes)-1] + } + var nodeAt func(int) *OrgSubscription + if last != nil { + n := len(nodes) - 1 + nodeAt = func(i int) *OrgSubscription { + return nodes[n-i] + } + } else { + nodeAt = func(i int) *OrgSubscription { + return nodes[i] + } + } + c.Edges = make([]*OrgSubscriptionEdge, len(nodes)) + for i := range nodes { + node := nodeAt(i) + c.Edges[i] = &OrgSubscriptionEdge{ + Node: node, + Cursor: pager.toCursor(node), + } + } + if l := len(c.Edges); l > 0 { + c.PageInfo.StartCursor = &c.Edges[0].Cursor + c.PageInfo.EndCursor = &c.Edges[l-1].Cursor + } + if c.TotalCount == 0 { + c.TotalCount = len(nodes) + } +} + +// OrgSubscriptionPaginateOption enables pagination customization. +type OrgSubscriptionPaginateOption func(*orgsubscriptionPager) error + +// WithOrgSubscriptionOrder configures pagination ordering. +func WithOrgSubscriptionOrder(order *OrgSubscriptionOrder) OrgSubscriptionPaginateOption { + if order == nil { + order = DefaultOrgSubscriptionOrder + } + o := *order + return func(pager *orgsubscriptionPager) error { + if err := o.Direction.Validate(); err != nil { + return err + } + if o.Field == nil { + o.Field = DefaultOrgSubscriptionOrder.Field + } + pager.order = &o + return nil + } +} + +// WithOrgSubscriptionFilter configures pagination filter. +func WithOrgSubscriptionFilter(filter func(*OrgSubscriptionQuery) (*OrgSubscriptionQuery, error)) OrgSubscriptionPaginateOption { + return func(pager *orgsubscriptionPager) error { + if filter == nil { + return errors.New("OrgSubscriptionQuery filter cannot be nil") + } + pager.filter = filter + return nil + } +} + +type orgsubscriptionPager struct { + reverse bool + order *OrgSubscriptionOrder + filter func(*OrgSubscriptionQuery) (*OrgSubscriptionQuery, error) +} + +func newOrgSubscriptionPager(opts []OrgSubscriptionPaginateOption, reverse bool) (*orgsubscriptionPager, error) { + pager := &orgsubscriptionPager{reverse: reverse} + for _, opt := range opts { + if err := opt(pager); err != nil { + return nil, err + } + } + if pager.order == nil { + pager.order = DefaultOrgSubscriptionOrder + } + return pager, nil +} + +func (p *orgsubscriptionPager) applyFilter(query *OrgSubscriptionQuery) (*OrgSubscriptionQuery, error) { + if p.filter != nil { + return p.filter(query) + } + return query, nil +} + +func (p *orgsubscriptionPager) toCursor(os *OrgSubscription) Cursor { + return p.order.Field.toCursor(os) +} + +func (p *orgsubscriptionPager) applyCursors(query *OrgSubscriptionQuery, after, before *Cursor) (*OrgSubscriptionQuery, error) { + direction := p.order.Direction + if p.reverse { + direction = direction.Reverse() + } + for _, predicate := range entgql.CursorsPredicate(after, before, DefaultOrgSubscriptionOrder.Field.column, p.order.Field.column, direction) { + query = query.Where(predicate) + } + return query, nil +} + +func (p *orgsubscriptionPager) applyOrder(query *OrgSubscriptionQuery) *OrgSubscriptionQuery { + direction := p.order.Direction + if p.reverse { + direction = direction.Reverse() + } + query = query.Order(p.order.Field.toTerm(direction.OrderTermOption())) + if p.order.Field != DefaultOrgSubscriptionOrder.Field { + query = query.Order(DefaultOrgSubscriptionOrder.Field.toTerm(direction.OrderTermOption())) + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(p.order.Field.column) + } + return query +} + +func (p *orgsubscriptionPager) orderExpr(query *OrgSubscriptionQuery) sql.Querier { + direction := p.order.Direction + if p.reverse { + direction = direction.Reverse() + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(p.order.Field.column) + } + return sql.ExprFunc(func(b *sql.Builder) { + b.Ident(p.order.Field.column).Pad().WriteString(string(direction)) + if p.order.Field != DefaultOrgSubscriptionOrder.Field { + b.Comma().Ident(DefaultOrgSubscriptionOrder.Field.column).Pad().WriteString(string(direction)) + } + }) +} + +// Paginate executes the query and returns a relay based cursor connection to OrgSubscription. +func (os *OrgSubscriptionQuery) Paginate( + ctx context.Context, after *Cursor, first *int, + before *Cursor, last *int, opts ...OrgSubscriptionPaginateOption, +) (*OrgSubscriptionConnection, error) { + if err := validateFirstLast(first, last); err != nil { + return nil, err + } + pager, err := newOrgSubscriptionPager(opts, last != nil) + if err != nil { + return nil, err + } + if os, err = pager.applyFilter(os); err != nil { + return nil, err + } + conn := &OrgSubscriptionConnection{Edges: []*OrgSubscriptionEdge{}} + ignoredEdges := !hasCollectedField(ctx, edgesField) + if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) { + hasPagination := after != nil || first != nil || before != nil || last != nil + if hasPagination || ignoredEdges { + c := os.Clone() + c.ctx.Fields = nil + if conn.TotalCount, err = c.Count(ctx); err != nil { + return nil, err + } + conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0 + conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0 + } + } + if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) { + return conn, nil + } + if os, err = pager.applyCursors(os, after, before); err != nil { + return nil, err + } + limit := paginateLimit(first, last) + if limit != 0 { + os.Limit(limit) + } + if field := collectedField(ctx, edgesField, nodeField); field != nil { + if err := os.collectField(ctx, limit == 1, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil { + return nil, err + } + } + os = pager.applyOrder(os) + nodes, err := os.All(ctx) + if err != nil { + return nil, err + } + conn.build(nodes, pager, after, first, before, last) + return conn, nil +} + +// OrgSubscriptionOrderField defines the ordering field of OrgSubscription. +type OrgSubscriptionOrderField struct { + // Value extracts the ordering value from the given OrgSubscription. + Value func(*OrgSubscription) (ent.Value, error) + column string // field or computed. + toTerm func(...sql.OrderTermOption) orgsubscription.OrderOption + toCursor func(*OrgSubscription) Cursor +} + +// OrgSubscriptionOrder defines the ordering of OrgSubscription. +type OrgSubscriptionOrder struct { + Direction OrderDirection `json:"direction"` + Field *OrgSubscriptionOrderField `json:"field"` +} + +// DefaultOrgSubscriptionOrder is the default ordering of OrgSubscription. +var DefaultOrgSubscriptionOrder = &OrgSubscriptionOrder{ + Direction: entgql.OrderDirectionAsc, + Field: &OrgSubscriptionOrderField{ + Value: func(os *OrgSubscription) (ent.Value, error) { + return os.ID, nil + }, + column: orgsubscription.FieldID, + toTerm: orgsubscription.ByID, + toCursor: func(os *OrgSubscription) Cursor { + return Cursor{ID: os.ID} + }, + }, +} + +// ToEdge converts OrgSubscription into OrgSubscriptionEdge. +func (os *OrgSubscription) ToEdge(order *OrgSubscriptionOrder) *OrgSubscriptionEdge { + if order == nil { + order = DefaultOrgSubscriptionOrder + } + return &OrgSubscriptionEdge{ + Node: os, + Cursor: order.Field.toCursor(os), + } +} + +// OrgSubscriptionHistoryEdge is the edge representation of OrgSubscriptionHistory. +type OrgSubscriptionHistoryEdge struct { + Node *OrgSubscriptionHistory `json:"node"` + Cursor Cursor `json:"cursor"` +} + +// OrgSubscriptionHistoryConnection is the connection containing edges to OrgSubscriptionHistory. +type OrgSubscriptionHistoryConnection struct { + Edges []*OrgSubscriptionHistoryEdge `json:"edges"` + PageInfo PageInfo `json:"pageInfo"` + TotalCount int `json:"totalCount"` +} + +func (c *OrgSubscriptionHistoryConnection) build(nodes []*OrgSubscriptionHistory, pager *orgsubscriptionhistoryPager, after *Cursor, first *int, before *Cursor, last *int) { + c.PageInfo.HasNextPage = before != nil + c.PageInfo.HasPreviousPage = after != nil + if first != nil && *first+1 == len(nodes) { + c.PageInfo.HasNextPage = true + nodes = nodes[:len(nodes)-1] + } else if last != nil && *last+1 == len(nodes) { + c.PageInfo.HasPreviousPage = true + nodes = nodes[:len(nodes)-1] + } + var nodeAt func(int) *OrgSubscriptionHistory + if last != nil { + n := len(nodes) - 1 + nodeAt = func(i int) *OrgSubscriptionHistory { + return nodes[n-i] + } + } else { + nodeAt = func(i int) *OrgSubscriptionHistory { + return nodes[i] + } + } + c.Edges = make([]*OrgSubscriptionHistoryEdge, len(nodes)) + for i := range nodes { + node := nodeAt(i) + c.Edges[i] = &OrgSubscriptionHistoryEdge{ + Node: node, + Cursor: pager.toCursor(node), + } + } + if l := len(c.Edges); l > 0 { + c.PageInfo.StartCursor = &c.Edges[0].Cursor + c.PageInfo.EndCursor = &c.Edges[l-1].Cursor + } + if c.TotalCount == 0 { + c.TotalCount = len(nodes) + } +} + +// OrgSubscriptionHistoryPaginateOption enables pagination customization. +type OrgSubscriptionHistoryPaginateOption func(*orgsubscriptionhistoryPager) error + +// WithOrgSubscriptionHistoryOrder configures pagination ordering. +func WithOrgSubscriptionHistoryOrder(order *OrgSubscriptionHistoryOrder) OrgSubscriptionHistoryPaginateOption { + if order == nil { + order = DefaultOrgSubscriptionHistoryOrder + } + o := *order + return func(pager *orgsubscriptionhistoryPager) error { + if err := o.Direction.Validate(); err != nil { + return err + } + if o.Field == nil { + o.Field = DefaultOrgSubscriptionHistoryOrder.Field + } + pager.order = &o + return nil + } +} + +// WithOrgSubscriptionHistoryFilter configures pagination filter. +func WithOrgSubscriptionHistoryFilter(filter func(*OrgSubscriptionHistoryQuery) (*OrgSubscriptionHistoryQuery, error)) OrgSubscriptionHistoryPaginateOption { + return func(pager *orgsubscriptionhistoryPager) error { + if filter == nil { + return errors.New("OrgSubscriptionHistoryQuery filter cannot be nil") + } + pager.filter = filter + return nil + } +} + +type orgsubscriptionhistoryPager struct { + reverse bool + order *OrgSubscriptionHistoryOrder + filter func(*OrgSubscriptionHistoryQuery) (*OrgSubscriptionHistoryQuery, error) +} + +func newOrgSubscriptionHistoryPager(opts []OrgSubscriptionHistoryPaginateOption, reverse bool) (*orgsubscriptionhistoryPager, error) { + pager := &orgsubscriptionhistoryPager{reverse: reverse} + for _, opt := range opts { + if err := opt(pager); err != nil { + return nil, err + } + } + if pager.order == nil { + pager.order = DefaultOrgSubscriptionHistoryOrder + } + return pager, nil +} + +func (p *orgsubscriptionhistoryPager) applyFilter(query *OrgSubscriptionHistoryQuery) (*OrgSubscriptionHistoryQuery, error) { + if p.filter != nil { + return p.filter(query) + } + return query, nil +} + +func (p *orgsubscriptionhistoryPager) toCursor(osh *OrgSubscriptionHistory) Cursor { + return p.order.Field.toCursor(osh) +} + +func (p *orgsubscriptionhistoryPager) applyCursors(query *OrgSubscriptionHistoryQuery, after, before *Cursor) (*OrgSubscriptionHistoryQuery, error) { + direction := p.order.Direction + if p.reverse { + direction = direction.Reverse() + } + for _, predicate := range entgql.CursorsPredicate(after, before, DefaultOrgSubscriptionHistoryOrder.Field.column, p.order.Field.column, direction) { + query = query.Where(predicate) + } + return query, nil +} + +func (p *orgsubscriptionhistoryPager) applyOrder(query *OrgSubscriptionHistoryQuery) *OrgSubscriptionHistoryQuery { + direction := p.order.Direction + if p.reverse { + direction = direction.Reverse() + } + query = query.Order(p.order.Field.toTerm(direction.OrderTermOption())) + if p.order.Field != DefaultOrgSubscriptionHistoryOrder.Field { + query = query.Order(DefaultOrgSubscriptionHistoryOrder.Field.toTerm(direction.OrderTermOption())) + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(p.order.Field.column) + } + return query +} + +func (p *orgsubscriptionhistoryPager) orderExpr(query *OrgSubscriptionHistoryQuery) sql.Querier { + direction := p.order.Direction + if p.reverse { + direction = direction.Reverse() + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(p.order.Field.column) + } + return sql.ExprFunc(func(b *sql.Builder) { + b.Ident(p.order.Field.column).Pad().WriteString(string(direction)) + if p.order.Field != DefaultOrgSubscriptionHistoryOrder.Field { + b.Comma().Ident(DefaultOrgSubscriptionHistoryOrder.Field.column).Pad().WriteString(string(direction)) + } + }) +} + +// Paginate executes the query and returns a relay based cursor connection to OrgSubscriptionHistory. +func (osh *OrgSubscriptionHistoryQuery) Paginate( + ctx context.Context, after *Cursor, first *int, + before *Cursor, last *int, opts ...OrgSubscriptionHistoryPaginateOption, +) (*OrgSubscriptionHistoryConnection, error) { + if err := validateFirstLast(first, last); err != nil { + return nil, err + } + pager, err := newOrgSubscriptionHistoryPager(opts, last != nil) + if err != nil { + return nil, err + } + if osh, err = pager.applyFilter(osh); err != nil { + return nil, err + } + conn := &OrgSubscriptionHistoryConnection{Edges: []*OrgSubscriptionHistoryEdge{}} + ignoredEdges := !hasCollectedField(ctx, edgesField) + if hasCollectedField(ctx, totalCountField) || hasCollectedField(ctx, pageInfoField) { + hasPagination := after != nil || first != nil || before != nil || last != nil + if hasPagination || ignoredEdges { + c := osh.Clone() + c.ctx.Fields = nil + if conn.TotalCount, err = c.Count(ctx); err != nil { + return nil, err + } + conn.PageInfo.HasNextPage = first != nil && conn.TotalCount > 0 + conn.PageInfo.HasPreviousPage = last != nil && conn.TotalCount > 0 + } + } + if ignoredEdges || (first != nil && *first == 0) || (last != nil && *last == 0) { + return conn, nil + } + if osh, err = pager.applyCursors(osh, after, before); err != nil { + return nil, err + } + limit := paginateLimit(first, last) + if limit != 0 { + osh.Limit(limit) + } + if field := collectedField(ctx, edgesField, nodeField); field != nil { + if err := osh.collectField(ctx, limit == 1, graphql.GetOperationContext(ctx), *field, []string{edgesField, nodeField}); err != nil { + return nil, err + } + } + osh = pager.applyOrder(osh) + nodes, err := osh.All(ctx) + if err != nil { + return nil, err + } + conn.build(nodes, pager, after, first, before, last) + return conn, nil +} + +// OrgSubscriptionHistoryOrderField defines the ordering field of OrgSubscriptionHistory. +type OrgSubscriptionHistoryOrderField struct { + // Value extracts the ordering value from the given OrgSubscriptionHistory. + Value func(*OrgSubscriptionHistory) (ent.Value, error) + column string // field or computed. + toTerm func(...sql.OrderTermOption) orgsubscriptionhistory.OrderOption + toCursor func(*OrgSubscriptionHistory) Cursor +} + +// OrgSubscriptionHistoryOrder defines the ordering of OrgSubscriptionHistory. +type OrgSubscriptionHistoryOrder struct { + Direction OrderDirection `json:"direction"` + Field *OrgSubscriptionHistoryOrderField `json:"field"` +} + +// DefaultOrgSubscriptionHistoryOrder is the default ordering of OrgSubscriptionHistory. +var DefaultOrgSubscriptionHistoryOrder = &OrgSubscriptionHistoryOrder{ + Direction: entgql.OrderDirectionAsc, + Field: &OrgSubscriptionHistoryOrderField{ + Value: func(osh *OrgSubscriptionHistory) (ent.Value, error) { + return osh.ID, nil + }, + column: orgsubscriptionhistory.FieldID, + toTerm: orgsubscriptionhistory.ByID, + toCursor: func(osh *OrgSubscriptionHistory) Cursor { + return Cursor{ID: osh.ID} + }, + }, +} + +// ToEdge converts OrgSubscriptionHistory into OrgSubscriptionHistoryEdge. +func (osh *OrgSubscriptionHistory) ToEdge(order *OrgSubscriptionHistoryOrder) *OrgSubscriptionHistoryEdge { + if order == nil { + order = DefaultOrgSubscriptionHistoryOrder + } + return &OrgSubscriptionHistoryEdge{ + Node: osh, + Cursor: order.Field.toCursor(osh), + } +} + // OrganizationEdge is the edge representation of Organization. type OrganizationEdge struct { Node *Organization `json:"node"` diff --git a/internal/ent/generated/gql_where_input.go b/internal/ent/generated/gql_where_input.go index 95a455f1..16c8343f 100644 --- a/internal/ent/generated/gql_where_input.go +++ b/internal/ent/generated/gql_where_input.go @@ -61,6 +61,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/predicate" "github.com/theopenlane/core/internal/ent/generated/procedure" @@ -43373,6 +43375,1878 @@ func (i *OrgMembershipHistoryWhereInput) P() (predicate.OrgMembershipHistory, er } } +// OrgSubscriptionWhereInput represents a where input for filtering OrgSubscription queries. +type OrgSubscriptionWhereInput struct { + Predicates []predicate.OrgSubscription `json:"-"` + Not *OrgSubscriptionWhereInput `json:"not,omitempty"` + Or []*OrgSubscriptionWhereInput `json:"or,omitempty"` + And []*OrgSubscriptionWhereInput `json:"and,omitempty"` + + // "id" field predicates. + ID *string `json:"id,omitempty"` + IDNEQ *string `json:"idNEQ,omitempty"` + IDIn []string `json:"idIn,omitempty"` + IDNotIn []string `json:"idNotIn,omitempty"` + IDGT *string `json:"idGT,omitempty"` + IDGTE *string `json:"idGTE,omitempty"` + IDLT *string `json:"idLT,omitempty"` + IDLTE *string `json:"idLTE,omitempty"` + IDEqualFold *string `json:"idEqualFold,omitempty"` + IDContainsFold *string `json:"idContainsFold,omitempty"` + + // "created_at" field predicates. + CreatedAt *time.Time `json:"createdAt,omitempty"` + CreatedAtNEQ *time.Time `json:"createdAtNEQ,omitempty"` + CreatedAtIn []time.Time `json:"createdAtIn,omitempty"` + CreatedAtNotIn []time.Time `json:"createdAtNotIn,omitempty"` + CreatedAtGT *time.Time `json:"createdAtGT,omitempty"` + CreatedAtGTE *time.Time `json:"createdAtGTE,omitempty"` + CreatedAtLT *time.Time `json:"createdAtLT,omitempty"` + CreatedAtLTE *time.Time `json:"createdAtLTE,omitempty"` + CreatedAtIsNil bool `json:"createdAtIsNil,omitempty"` + CreatedAtNotNil bool `json:"createdAtNotNil,omitempty"` + + // "updated_at" field predicates. + UpdatedAt *time.Time `json:"updatedAt,omitempty"` + UpdatedAtNEQ *time.Time `json:"updatedAtNEQ,omitempty"` + UpdatedAtIn []time.Time `json:"updatedAtIn,omitempty"` + UpdatedAtNotIn []time.Time `json:"updatedAtNotIn,omitempty"` + UpdatedAtGT *time.Time `json:"updatedAtGT,omitempty"` + UpdatedAtGTE *time.Time `json:"updatedAtGTE,omitempty"` + UpdatedAtLT *time.Time `json:"updatedAtLT,omitempty"` + UpdatedAtLTE *time.Time `json:"updatedAtLTE,omitempty"` + UpdatedAtIsNil bool `json:"updatedAtIsNil,omitempty"` + UpdatedAtNotNil bool `json:"updatedAtNotNil,omitempty"` + + // "created_by" field predicates. + CreatedBy *string `json:"createdBy,omitempty"` + CreatedByNEQ *string `json:"createdByNEQ,omitempty"` + CreatedByIn []string `json:"createdByIn,omitempty"` + CreatedByNotIn []string `json:"createdByNotIn,omitempty"` + CreatedByGT *string `json:"createdByGT,omitempty"` + CreatedByGTE *string `json:"createdByGTE,omitempty"` + CreatedByLT *string `json:"createdByLT,omitempty"` + CreatedByLTE *string `json:"createdByLTE,omitempty"` + CreatedByContains *string `json:"createdByContains,omitempty"` + CreatedByHasPrefix *string `json:"createdByHasPrefix,omitempty"` + CreatedByHasSuffix *string `json:"createdByHasSuffix,omitempty"` + CreatedByIsNil bool `json:"createdByIsNil,omitempty"` + CreatedByNotNil bool `json:"createdByNotNil,omitempty"` + CreatedByEqualFold *string `json:"createdByEqualFold,omitempty"` + CreatedByContainsFold *string `json:"createdByContainsFold,omitempty"` + + // "updated_by" field predicates. + UpdatedBy *string `json:"updatedBy,omitempty"` + UpdatedByNEQ *string `json:"updatedByNEQ,omitempty"` + UpdatedByIn []string `json:"updatedByIn,omitempty"` + UpdatedByNotIn []string `json:"updatedByNotIn,omitempty"` + UpdatedByGT *string `json:"updatedByGT,omitempty"` + UpdatedByGTE *string `json:"updatedByGTE,omitempty"` + UpdatedByLT *string `json:"updatedByLT,omitempty"` + UpdatedByLTE *string `json:"updatedByLTE,omitempty"` + UpdatedByContains *string `json:"updatedByContains,omitempty"` + UpdatedByHasPrefix *string `json:"updatedByHasPrefix,omitempty"` + UpdatedByHasSuffix *string `json:"updatedByHasSuffix,omitempty"` + UpdatedByIsNil bool `json:"updatedByIsNil,omitempty"` + UpdatedByNotNil bool `json:"updatedByNotNil,omitempty"` + UpdatedByEqualFold *string `json:"updatedByEqualFold,omitempty"` + UpdatedByContainsFold *string `json:"updatedByContainsFold,omitempty"` + + // "deleted_at" field predicates. + DeletedAt *time.Time `json:"deletedAt,omitempty"` + DeletedAtNEQ *time.Time `json:"deletedAtNEQ,omitempty"` + DeletedAtIn []time.Time `json:"deletedAtIn,omitempty"` + DeletedAtNotIn []time.Time `json:"deletedAtNotIn,omitempty"` + DeletedAtGT *time.Time `json:"deletedAtGT,omitempty"` + DeletedAtGTE *time.Time `json:"deletedAtGTE,omitempty"` + DeletedAtLT *time.Time `json:"deletedAtLT,omitempty"` + DeletedAtLTE *time.Time `json:"deletedAtLTE,omitempty"` + DeletedAtIsNil bool `json:"deletedAtIsNil,omitempty"` + DeletedAtNotNil bool `json:"deletedAtNotNil,omitempty"` + + // "deleted_by" field predicates. + DeletedBy *string `json:"deletedBy,omitempty"` + DeletedByNEQ *string `json:"deletedByNEQ,omitempty"` + DeletedByIn []string `json:"deletedByIn,omitempty"` + DeletedByNotIn []string `json:"deletedByNotIn,omitempty"` + DeletedByGT *string `json:"deletedByGT,omitempty"` + DeletedByGTE *string `json:"deletedByGTE,omitempty"` + DeletedByLT *string `json:"deletedByLT,omitempty"` + DeletedByLTE *string `json:"deletedByLTE,omitempty"` + DeletedByContains *string `json:"deletedByContains,omitempty"` + DeletedByHasPrefix *string `json:"deletedByHasPrefix,omitempty"` + DeletedByHasSuffix *string `json:"deletedByHasSuffix,omitempty"` + DeletedByIsNil bool `json:"deletedByIsNil,omitempty"` + DeletedByNotNil bool `json:"deletedByNotNil,omitempty"` + DeletedByEqualFold *string `json:"deletedByEqualFold,omitempty"` + DeletedByContainsFold *string `json:"deletedByContainsFold,omitempty"` + + // "owner_id" field predicates. + OwnerID *string `json:"ownerID,omitempty"` + OwnerIDNEQ *string `json:"ownerIDNEQ,omitempty"` + OwnerIDIn []string `json:"ownerIDIn,omitempty"` + OwnerIDNotIn []string `json:"ownerIDNotIn,omitempty"` + OwnerIDGT *string `json:"ownerIDGT,omitempty"` + OwnerIDGTE *string `json:"ownerIDGTE,omitempty"` + OwnerIDLT *string `json:"ownerIDLT,omitempty"` + OwnerIDLTE *string `json:"ownerIDLTE,omitempty"` + OwnerIDContains *string `json:"ownerIDContains,omitempty"` + OwnerIDHasPrefix *string `json:"ownerIDHasPrefix,omitempty"` + OwnerIDHasSuffix *string `json:"ownerIDHasSuffix,omitempty"` + OwnerIDIsNil bool `json:"ownerIDIsNil,omitempty"` + OwnerIDNotNil bool `json:"ownerIDNotNil,omitempty"` + OwnerIDEqualFold *string `json:"ownerIDEqualFold,omitempty"` + OwnerIDContainsFold *string `json:"ownerIDContainsFold,omitempty"` + + // "stripe_subscription_id" field predicates. + StripeSubscriptionID *string `json:"stripeSubscriptionID,omitempty"` + StripeSubscriptionIDNEQ *string `json:"stripeSubscriptionIDNEQ,omitempty"` + StripeSubscriptionIDIn []string `json:"stripeSubscriptionIDIn,omitempty"` + StripeSubscriptionIDNotIn []string `json:"stripeSubscriptionIDNotIn,omitempty"` + StripeSubscriptionIDGT *string `json:"stripeSubscriptionIDGT,omitempty"` + StripeSubscriptionIDGTE *string `json:"stripeSubscriptionIDGTE,omitempty"` + StripeSubscriptionIDLT *string `json:"stripeSubscriptionIDLT,omitempty"` + StripeSubscriptionIDLTE *string `json:"stripeSubscriptionIDLTE,omitempty"` + StripeSubscriptionIDContains *string `json:"stripeSubscriptionIDContains,omitempty"` + StripeSubscriptionIDHasPrefix *string `json:"stripeSubscriptionIDHasPrefix,omitempty"` + StripeSubscriptionIDHasSuffix *string `json:"stripeSubscriptionIDHasSuffix,omitempty"` + StripeSubscriptionIDIsNil bool `json:"stripeSubscriptionIDIsNil,omitempty"` + StripeSubscriptionIDNotNil bool `json:"stripeSubscriptionIDNotNil,omitempty"` + StripeSubscriptionIDEqualFold *string `json:"stripeSubscriptionIDEqualFold,omitempty"` + StripeSubscriptionIDContainsFold *string `json:"stripeSubscriptionIDContainsFold,omitempty"` + + // "product_tier" field predicates. + ProductTier *string `json:"productTier,omitempty"` + ProductTierNEQ *string `json:"productTierNEQ,omitempty"` + ProductTierIn []string `json:"productTierIn,omitempty"` + ProductTierNotIn []string `json:"productTierNotIn,omitempty"` + ProductTierGT *string `json:"productTierGT,omitempty"` + ProductTierGTE *string `json:"productTierGTE,omitempty"` + ProductTierLT *string `json:"productTierLT,omitempty"` + ProductTierLTE *string `json:"productTierLTE,omitempty"` + ProductTierContains *string `json:"productTierContains,omitempty"` + ProductTierHasPrefix *string `json:"productTierHasPrefix,omitempty"` + ProductTierHasSuffix *string `json:"productTierHasSuffix,omitempty"` + ProductTierIsNil bool `json:"productTierIsNil,omitempty"` + ProductTierNotNil bool `json:"productTierNotNil,omitempty"` + ProductTierEqualFold *string `json:"productTierEqualFold,omitempty"` + ProductTierContainsFold *string `json:"productTierContainsFold,omitempty"` + + // "stripe_product_tier_id" field predicates. + StripeProductTierID *string `json:"stripeProductTierID,omitempty"` + StripeProductTierIDNEQ *string `json:"stripeProductTierIDNEQ,omitempty"` + StripeProductTierIDIn []string `json:"stripeProductTierIDIn,omitempty"` + StripeProductTierIDNotIn []string `json:"stripeProductTierIDNotIn,omitempty"` + StripeProductTierIDGT *string `json:"stripeProductTierIDGT,omitempty"` + StripeProductTierIDGTE *string `json:"stripeProductTierIDGTE,omitempty"` + StripeProductTierIDLT *string `json:"stripeProductTierIDLT,omitempty"` + StripeProductTierIDLTE *string `json:"stripeProductTierIDLTE,omitempty"` + StripeProductTierIDContains *string `json:"stripeProductTierIDContains,omitempty"` + StripeProductTierIDHasPrefix *string `json:"stripeProductTierIDHasPrefix,omitempty"` + StripeProductTierIDHasSuffix *string `json:"stripeProductTierIDHasSuffix,omitempty"` + StripeProductTierIDIsNil bool `json:"stripeProductTierIDIsNil,omitempty"` + StripeProductTierIDNotNil bool `json:"stripeProductTierIDNotNil,omitempty"` + StripeProductTierIDEqualFold *string `json:"stripeProductTierIDEqualFold,omitempty"` + StripeProductTierIDContainsFold *string `json:"stripeProductTierIDContainsFold,omitempty"` + + // "stripe_subscription_status" field predicates. + StripeSubscriptionStatus *string `json:"stripeSubscriptionStatus,omitempty"` + StripeSubscriptionStatusNEQ *string `json:"stripeSubscriptionStatusNEQ,omitempty"` + StripeSubscriptionStatusIn []string `json:"stripeSubscriptionStatusIn,omitempty"` + StripeSubscriptionStatusNotIn []string `json:"stripeSubscriptionStatusNotIn,omitempty"` + StripeSubscriptionStatusGT *string `json:"stripeSubscriptionStatusGT,omitempty"` + StripeSubscriptionStatusGTE *string `json:"stripeSubscriptionStatusGTE,omitempty"` + StripeSubscriptionStatusLT *string `json:"stripeSubscriptionStatusLT,omitempty"` + StripeSubscriptionStatusLTE *string `json:"stripeSubscriptionStatusLTE,omitempty"` + StripeSubscriptionStatusContains *string `json:"stripeSubscriptionStatusContains,omitempty"` + StripeSubscriptionStatusHasPrefix *string `json:"stripeSubscriptionStatusHasPrefix,omitempty"` + StripeSubscriptionStatusHasSuffix *string `json:"stripeSubscriptionStatusHasSuffix,omitempty"` + StripeSubscriptionStatusIsNil bool `json:"stripeSubscriptionStatusIsNil,omitempty"` + StripeSubscriptionStatusNotNil bool `json:"stripeSubscriptionStatusNotNil,omitempty"` + StripeSubscriptionStatusEqualFold *string `json:"stripeSubscriptionStatusEqualFold,omitempty"` + StripeSubscriptionStatusContainsFold *string `json:"stripeSubscriptionStatusContainsFold,omitempty"` + + // "active" field predicates. + Active *bool `json:"active,omitempty"` + ActiveNEQ *bool `json:"activeNEQ,omitempty"` + + // "stripe_customer_id" field predicates. + StripeCustomerID *string `json:"stripeCustomerID,omitempty"` + StripeCustomerIDNEQ *string `json:"stripeCustomerIDNEQ,omitempty"` + StripeCustomerIDIn []string `json:"stripeCustomerIDIn,omitempty"` + StripeCustomerIDNotIn []string `json:"stripeCustomerIDNotIn,omitempty"` + StripeCustomerIDGT *string `json:"stripeCustomerIDGT,omitempty"` + StripeCustomerIDGTE *string `json:"stripeCustomerIDGTE,omitempty"` + StripeCustomerIDLT *string `json:"stripeCustomerIDLT,omitempty"` + StripeCustomerIDLTE *string `json:"stripeCustomerIDLTE,omitempty"` + StripeCustomerIDContains *string `json:"stripeCustomerIDContains,omitempty"` + StripeCustomerIDHasPrefix *string `json:"stripeCustomerIDHasPrefix,omitempty"` + StripeCustomerIDHasSuffix *string `json:"stripeCustomerIDHasSuffix,omitempty"` + StripeCustomerIDIsNil bool `json:"stripeCustomerIDIsNil,omitempty"` + StripeCustomerIDNotNil bool `json:"stripeCustomerIDNotNil,omitempty"` + StripeCustomerIDEqualFold *string `json:"stripeCustomerIDEqualFold,omitempty"` + StripeCustomerIDContainsFold *string `json:"stripeCustomerIDContainsFold,omitempty"` + + // "expires_at" field predicates. + ExpiresAt *time.Time `json:"expiresAt,omitempty"` + ExpiresAtNEQ *time.Time `json:"expiresAtNEQ,omitempty"` + ExpiresAtIn []time.Time `json:"expiresAtIn,omitempty"` + ExpiresAtNotIn []time.Time `json:"expiresAtNotIn,omitempty"` + ExpiresAtGT *time.Time `json:"expiresAtGT,omitempty"` + ExpiresAtGTE *time.Time `json:"expiresAtGTE,omitempty"` + ExpiresAtLT *time.Time `json:"expiresAtLT,omitempty"` + ExpiresAtLTE *time.Time `json:"expiresAtLTE,omitempty"` + ExpiresAtIsNil bool `json:"expiresAtIsNil,omitempty"` + ExpiresAtNotNil bool `json:"expiresAtNotNil,omitempty"` + + // "owner" edge predicates. + HasOwner *bool `json:"hasOwner,omitempty"` + HasOwnerWith []*OrganizationWhereInput `json:"hasOwnerWith,omitempty"` +} + +// AddPredicates adds custom predicates to the where input to be used during the filtering phase. +func (i *OrgSubscriptionWhereInput) AddPredicates(predicates ...predicate.OrgSubscription) { + i.Predicates = append(i.Predicates, predicates...) +} + +// Filter applies the OrgSubscriptionWhereInput filter on the OrgSubscriptionQuery builder. +func (i *OrgSubscriptionWhereInput) Filter(q *OrgSubscriptionQuery) (*OrgSubscriptionQuery, error) { + if i == nil { + return q, nil + } + p, err := i.P() + if err != nil { + if err == ErrEmptyOrgSubscriptionWhereInput { + return q, nil + } + return nil, err + } + return q.Where(p), nil +} + +// ErrEmptyOrgSubscriptionWhereInput is returned in case the OrgSubscriptionWhereInput is empty. +var ErrEmptyOrgSubscriptionWhereInput = errors.New("generated: empty predicate OrgSubscriptionWhereInput") + +// P returns a predicate for filtering orgsubscriptions. +// An error is returned if the input is empty or invalid. +func (i *OrgSubscriptionWhereInput) P() (predicate.OrgSubscription, error) { + var predicates []predicate.OrgSubscription + if i.Not != nil { + p, err := i.Not.P() + if err != nil { + return nil, fmt.Errorf("%w: field 'not'", err) + } + predicates = append(predicates, orgsubscription.Not(p)) + } + switch n := len(i.Or); { + case n == 1: + p, err := i.Or[0].P() + if err != nil { + return nil, fmt.Errorf("%w: field 'or'", err) + } + predicates = append(predicates, p) + case n > 1: + or := make([]predicate.OrgSubscription, 0, n) + for _, w := range i.Or { + p, err := w.P() + if err != nil { + return nil, fmt.Errorf("%w: field 'or'", err) + } + or = append(or, p) + } + predicates = append(predicates, orgsubscription.Or(or...)) + } + switch n := len(i.And); { + case n == 1: + p, err := i.And[0].P() + if err != nil { + return nil, fmt.Errorf("%w: field 'and'", err) + } + predicates = append(predicates, p) + case n > 1: + and := make([]predicate.OrgSubscription, 0, n) + for _, w := range i.And { + p, err := w.P() + if err != nil { + return nil, fmt.Errorf("%w: field 'and'", err) + } + and = append(and, p) + } + predicates = append(predicates, orgsubscription.And(and...)) + } + predicates = append(predicates, i.Predicates...) + if i.ID != nil { + predicates = append(predicates, orgsubscription.IDEQ(*i.ID)) + } + if i.IDNEQ != nil { + predicates = append(predicates, orgsubscription.IDNEQ(*i.IDNEQ)) + } + if len(i.IDIn) > 0 { + predicates = append(predicates, orgsubscription.IDIn(i.IDIn...)) + } + if len(i.IDNotIn) > 0 { + predicates = append(predicates, orgsubscription.IDNotIn(i.IDNotIn...)) + } + if i.IDGT != nil { + predicates = append(predicates, orgsubscription.IDGT(*i.IDGT)) + } + if i.IDGTE != nil { + predicates = append(predicates, orgsubscription.IDGTE(*i.IDGTE)) + } + if i.IDLT != nil { + predicates = append(predicates, orgsubscription.IDLT(*i.IDLT)) + } + if i.IDLTE != nil { + predicates = append(predicates, orgsubscription.IDLTE(*i.IDLTE)) + } + if i.IDEqualFold != nil { + predicates = append(predicates, orgsubscription.IDEqualFold(*i.IDEqualFold)) + } + if i.IDContainsFold != nil { + predicates = append(predicates, orgsubscription.IDContainsFold(*i.IDContainsFold)) + } + if i.CreatedAt != nil { + predicates = append(predicates, orgsubscription.CreatedAtEQ(*i.CreatedAt)) + } + if i.CreatedAtNEQ != nil { + predicates = append(predicates, orgsubscription.CreatedAtNEQ(*i.CreatedAtNEQ)) + } + if len(i.CreatedAtIn) > 0 { + predicates = append(predicates, orgsubscription.CreatedAtIn(i.CreatedAtIn...)) + } + if len(i.CreatedAtNotIn) > 0 { + predicates = append(predicates, orgsubscription.CreatedAtNotIn(i.CreatedAtNotIn...)) + } + if i.CreatedAtGT != nil { + predicates = append(predicates, orgsubscription.CreatedAtGT(*i.CreatedAtGT)) + } + if i.CreatedAtGTE != nil { + predicates = append(predicates, orgsubscription.CreatedAtGTE(*i.CreatedAtGTE)) + } + if i.CreatedAtLT != nil { + predicates = append(predicates, orgsubscription.CreatedAtLT(*i.CreatedAtLT)) + } + if i.CreatedAtLTE != nil { + predicates = append(predicates, orgsubscription.CreatedAtLTE(*i.CreatedAtLTE)) + } + if i.CreatedAtIsNil { + predicates = append(predicates, orgsubscription.CreatedAtIsNil()) + } + if i.CreatedAtNotNil { + predicates = append(predicates, orgsubscription.CreatedAtNotNil()) + } + if i.UpdatedAt != nil { + predicates = append(predicates, orgsubscription.UpdatedAtEQ(*i.UpdatedAt)) + } + if i.UpdatedAtNEQ != nil { + predicates = append(predicates, orgsubscription.UpdatedAtNEQ(*i.UpdatedAtNEQ)) + } + if len(i.UpdatedAtIn) > 0 { + predicates = append(predicates, orgsubscription.UpdatedAtIn(i.UpdatedAtIn...)) + } + if len(i.UpdatedAtNotIn) > 0 { + predicates = append(predicates, orgsubscription.UpdatedAtNotIn(i.UpdatedAtNotIn...)) + } + if i.UpdatedAtGT != nil { + predicates = append(predicates, orgsubscription.UpdatedAtGT(*i.UpdatedAtGT)) + } + if i.UpdatedAtGTE != nil { + predicates = append(predicates, orgsubscription.UpdatedAtGTE(*i.UpdatedAtGTE)) + } + if i.UpdatedAtLT != nil { + predicates = append(predicates, orgsubscription.UpdatedAtLT(*i.UpdatedAtLT)) + } + if i.UpdatedAtLTE != nil { + predicates = append(predicates, orgsubscription.UpdatedAtLTE(*i.UpdatedAtLTE)) + } + if i.UpdatedAtIsNil { + predicates = append(predicates, orgsubscription.UpdatedAtIsNil()) + } + if i.UpdatedAtNotNil { + predicates = append(predicates, orgsubscription.UpdatedAtNotNil()) + } + if i.CreatedBy != nil { + predicates = append(predicates, orgsubscription.CreatedByEQ(*i.CreatedBy)) + } + if i.CreatedByNEQ != nil { + predicates = append(predicates, orgsubscription.CreatedByNEQ(*i.CreatedByNEQ)) + } + if len(i.CreatedByIn) > 0 { + predicates = append(predicates, orgsubscription.CreatedByIn(i.CreatedByIn...)) + } + if len(i.CreatedByNotIn) > 0 { + predicates = append(predicates, orgsubscription.CreatedByNotIn(i.CreatedByNotIn...)) + } + if i.CreatedByGT != nil { + predicates = append(predicates, orgsubscription.CreatedByGT(*i.CreatedByGT)) + } + if i.CreatedByGTE != nil { + predicates = append(predicates, orgsubscription.CreatedByGTE(*i.CreatedByGTE)) + } + if i.CreatedByLT != nil { + predicates = append(predicates, orgsubscription.CreatedByLT(*i.CreatedByLT)) + } + if i.CreatedByLTE != nil { + predicates = append(predicates, orgsubscription.CreatedByLTE(*i.CreatedByLTE)) + } + if i.CreatedByContains != nil { + predicates = append(predicates, orgsubscription.CreatedByContains(*i.CreatedByContains)) + } + if i.CreatedByHasPrefix != nil { + predicates = append(predicates, orgsubscription.CreatedByHasPrefix(*i.CreatedByHasPrefix)) + } + if i.CreatedByHasSuffix != nil { + predicates = append(predicates, orgsubscription.CreatedByHasSuffix(*i.CreatedByHasSuffix)) + } + if i.CreatedByIsNil { + predicates = append(predicates, orgsubscription.CreatedByIsNil()) + } + if i.CreatedByNotNil { + predicates = append(predicates, orgsubscription.CreatedByNotNil()) + } + if i.CreatedByEqualFold != nil { + predicates = append(predicates, orgsubscription.CreatedByEqualFold(*i.CreatedByEqualFold)) + } + if i.CreatedByContainsFold != nil { + predicates = append(predicates, orgsubscription.CreatedByContainsFold(*i.CreatedByContainsFold)) + } + if i.UpdatedBy != nil { + predicates = append(predicates, orgsubscription.UpdatedByEQ(*i.UpdatedBy)) + } + if i.UpdatedByNEQ != nil { + predicates = append(predicates, orgsubscription.UpdatedByNEQ(*i.UpdatedByNEQ)) + } + if len(i.UpdatedByIn) > 0 { + predicates = append(predicates, orgsubscription.UpdatedByIn(i.UpdatedByIn...)) + } + if len(i.UpdatedByNotIn) > 0 { + predicates = append(predicates, orgsubscription.UpdatedByNotIn(i.UpdatedByNotIn...)) + } + if i.UpdatedByGT != nil { + predicates = append(predicates, orgsubscription.UpdatedByGT(*i.UpdatedByGT)) + } + if i.UpdatedByGTE != nil { + predicates = append(predicates, orgsubscription.UpdatedByGTE(*i.UpdatedByGTE)) + } + if i.UpdatedByLT != nil { + predicates = append(predicates, orgsubscription.UpdatedByLT(*i.UpdatedByLT)) + } + if i.UpdatedByLTE != nil { + predicates = append(predicates, orgsubscription.UpdatedByLTE(*i.UpdatedByLTE)) + } + if i.UpdatedByContains != nil { + predicates = append(predicates, orgsubscription.UpdatedByContains(*i.UpdatedByContains)) + } + if i.UpdatedByHasPrefix != nil { + predicates = append(predicates, orgsubscription.UpdatedByHasPrefix(*i.UpdatedByHasPrefix)) + } + if i.UpdatedByHasSuffix != nil { + predicates = append(predicates, orgsubscription.UpdatedByHasSuffix(*i.UpdatedByHasSuffix)) + } + if i.UpdatedByIsNil { + predicates = append(predicates, orgsubscription.UpdatedByIsNil()) + } + if i.UpdatedByNotNil { + predicates = append(predicates, orgsubscription.UpdatedByNotNil()) + } + if i.UpdatedByEqualFold != nil { + predicates = append(predicates, orgsubscription.UpdatedByEqualFold(*i.UpdatedByEqualFold)) + } + if i.UpdatedByContainsFold != nil { + predicates = append(predicates, orgsubscription.UpdatedByContainsFold(*i.UpdatedByContainsFold)) + } + if i.DeletedAt != nil { + predicates = append(predicates, orgsubscription.DeletedAtEQ(*i.DeletedAt)) + } + if i.DeletedAtNEQ != nil { + predicates = append(predicates, orgsubscription.DeletedAtNEQ(*i.DeletedAtNEQ)) + } + if len(i.DeletedAtIn) > 0 { + predicates = append(predicates, orgsubscription.DeletedAtIn(i.DeletedAtIn...)) + } + if len(i.DeletedAtNotIn) > 0 { + predicates = append(predicates, orgsubscription.DeletedAtNotIn(i.DeletedAtNotIn...)) + } + if i.DeletedAtGT != nil { + predicates = append(predicates, orgsubscription.DeletedAtGT(*i.DeletedAtGT)) + } + if i.DeletedAtGTE != nil { + predicates = append(predicates, orgsubscription.DeletedAtGTE(*i.DeletedAtGTE)) + } + if i.DeletedAtLT != nil { + predicates = append(predicates, orgsubscription.DeletedAtLT(*i.DeletedAtLT)) + } + if i.DeletedAtLTE != nil { + predicates = append(predicates, orgsubscription.DeletedAtLTE(*i.DeletedAtLTE)) + } + if i.DeletedAtIsNil { + predicates = append(predicates, orgsubscription.DeletedAtIsNil()) + } + if i.DeletedAtNotNil { + predicates = append(predicates, orgsubscription.DeletedAtNotNil()) + } + if i.DeletedBy != nil { + predicates = append(predicates, orgsubscription.DeletedByEQ(*i.DeletedBy)) + } + if i.DeletedByNEQ != nil { + predicates = append(predicates, orgsubscription.DeletedByNEQ(*i.DeletedByNEQ)) + } + if len(i.DeletedByIn) > 0 { + predicates = append(predicates, orgsubscription.DeletedByIn(i.DeletedByIn...)) + } + if len(i.DeletedByNotIn) > 0 { + predicates = append(predicates, orgsubscription.DeletedByNotIn(i.DeletedByNotIn...)) + } + if i.DeletedByGT != nil { + predicates = append(predicates, orgsubscription.DeletedByGT(*i.DeletedByGT)) + } + if i.DeletedByGTE != nil { + predicates = append(predicates, orgsubscription.DeletedByGTE(*i.DeletedByGTE)) + } + if i.DeletedByLT != nil { + predicates = append(predicates, orgsubscription.DeletedByLT(*i.DeletedByLT)) + } + if i.DeletedByLTE != nil { + predicates = append(predicates, orgsubscription.DeletedByLTE(*i.DeletedByLTE)) + } + if i.DeletedByContains != nil { + predicates = append(predicates, orgsubscription.DeletedByContains(*i.DeletedByContains)) + } + if i.DeletedByHasPrefix != nil { + predicates = append(predicates, orgsubscription.DeletedByHasPrefix(*i.DeletedByHasPrefix)) + } + if i.DeletedByHasSuffix != nil { + predicates = append(predicates, orgsubscription.DeletedByHasSuffix(*i.DeletedByHasSuffix)) + } + if i.DeletedByIsNil { + predicates = append(predicates, orgsubscription.DeletedByIsNil()) + } + if i.DeletedByNotNil { + predicates = append(predicates, orgsubscription.DeletedByNotNil()) + } + if i.DeletedByEqualFold != nil { + predicates = append(predicates, orgsubscription.DeletedByEqualFold(*i.DeletedByEqualFold)) + } + if i.DeletedByContainsFold != nil { + predicates = append(predicates, orgsubscription.DeletedByContainsFold(*i.DeletedByContainsFold)) + } + if i.OwnerID != nil { + predicates = append(predicates, orgsubscription.OwnerIDEQ(*i.OwnerID)) + } + if i.OwnerIDNEQ != nil { + predicates = append(predicates, orgsubscription.OwnerIDNEQ(*i.OwnerIDNEQ)) + } + if len(i.OwnerIDIn) > 0 { + predicates = append(predicates, orgsubscription.OwnerIDIn(i.OwnerIDIn...)) + } + if len(i.OwnerIDNotIn) > 0 { + predicates = append(predicates, orgsubscription.OwnerIDNotIn(i.OwnerIDNotIn...)) + } + if i.OwnerIDGT != nil { + predicates = append(predicates, orgsubscription.OwnerIDGT(*i.OwnerIDGT)) + } + if i.OwnerIDGTE != nil { + predicates = append(predicates, orgsubscription.OwnerIDGTE(*i.OwnerIDGTE)) + } + if i.OwnerIDLT != nil { + predicates = append(predicates, orgsubscription.OwnerIDLT(*i.OwnerIDLT)) + } + if i.OwnerIDLTE != nil { + predicates = append(predicates, orgsubscription.OwnerIDLTE(*i.OwnerIDLTE)) + } + if i.OwnerIDContains != nil { + predicates = append(predicates, orgsubscription.OwnerIDContains(*i.OwnerIDContains)) + } + if i.OwnerIDHasPrefix != nil { + predicates = append(predicates, orgsubscription.OwnerIDHasPrefix(*i.OwnerIDHasPrefix)) + } + if i.OwnerIDHasSuffix != nil { + predicates = append(predicates, orgsubscription.OwnerIDHasSuffix(*i.OwnerIDHasSuffix)) + } + if i.OwnerIDIsNil { + predicates = append(predicates, orgsubscription.OwnerIDIsNil()) + } + if i.OwnerIDNotNil { + predicates = append(predicates, orgsubscription.OwnerIDNotNil()) + } + if i.OwnerIDEqualFold != nil { + predicates = append(predicates, orgsubscription.OwnerIDEqualFold(*i.OwnerIDEqualFold)) + } + if i.OwnerIDContainsFold != nil { + predicates = append(predicates, orgsubscription.OwnerIDContainsFold(*i.OwnerIDContainsFold)) + } + if i.StripeSubscriptionID != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDEQ(*i.StripeSubscriptionID)) + } + if i.StripeSubscriptionIDNEQ != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDNEQ(*i.StripeSubscriptionIDNEQ)) + } + if len(i.StripeSubscriptionIDIn) > 0 { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDIn(i.StripeSubscriptionIDIn...)) + } + if len(i.StripeSubscriptionIDNotIn) > 0 { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDNotIn(i.StripeSubscriptionIDNotIn...)) + } + if i.StripeSubscriptionIDGT != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDGT(*i.StripeSubscriptionIDGT)) + } + if i.StripeSubscriptionIDGTE != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDGTE(*i.StripeSubscriptionIDGTE)) + } + if i.StripeSubscriptionIDLT != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDLT(*i.StripeSubscriptionIDLT)) + } + if i.StripeSubscriptionIDLTE != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDLTE(*i.StripeSubscriptionIDLTE)) + } + if i.StripeSubscriptionIDContains != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDContains(*i.StripeSubscriptionIDContains)) + } + if i.StripeSubscriptionIDHasPrefix != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDHasPrefix(*i.StripeSubscriptionIDHasPrefix)) + } + if i.StripeSubscriptionIDHasSuffix != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDHasSuffix(*i.StripeSubscriptionIDHasSuffix)) + } + if i.StripeSubscriptionIDIsNil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDIsNil()) + } + if i.StripeSubscriptionIDNotNil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDNotNil()) + } + if i.StripeSubscriptionIDEqualFold != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDEqualFold(*i.StripeSubscriptionIDEqualFold)) + } + if i.StripeSubscriptionIDContainsFold != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionIDContainsFold(*i.StripeSubscriptionIDContainsFold)) + } + if i.ProductTier != nil { + predicates = append(predicates, orgsubscription.ProductTierEQ(*i.ProductTier)) + } + if i.ProductTierNEQ != nil { + predicates = append(predicates, orgsubscription.ProductTierNEQ(*i.ProductTierNEQ)) + } + if len(i.ProductTierIn) > 0 { + predicates = append(predicates, orgsubscription.ProductTierIn(i.ProductTierIn...)) + } + if len(i.ProductTierNotIn) > 0 { + predicates = append(predicates, orgsubscription.ProductTierNotIn(i.ProductTierNotIn...)) + } + if i.ProductTierGT != nil { + predicates = append(predicates, orgsubscription.ProductTierGT(*i.ProductTierGT)) + } + if i.ProductTierGTE != nil { + predicates = append(predicates, orgsubscription.ProductTierGTE(*i.ProductTierGTE)) + } + if i.ProductTierLT != nil { + predicates = append(predicates, orgsubscription.ProductTierLT(*i.ProductTierLT)) + } + if i.ProductTierLTE != nil { + predicates = append(predicates, orgsubscription.ProductTierLTE(*i.ProductTierLTE)) + } + if i.ProductTierContains != nil { + predicates = append(predicates, orgsubscription.ProductTierContains(*i.ProductTierContains)) + } + if i.ProductTierHasPrefix != nil { + predicates = append(predicates, orgsubscription.ProductTierHasPrefix(*i.ProductTierHasPrefix)) + } + if i.ProductTierHasSuffix != nil { + predicates = append(predicates, orgsubscription.ProductTierHasSuffix(*i.ProductTierHasSuffix)) + } + if i.ProductTierIsNil { + predicates = append(predicates, orgsubscription.ProductTierIsNil()) + } + if i.ProductTierNotNil { + predicates = append(predicates, orgsubscription.ProductTierNotNil()) + } + if i.ProductTierEqualFold != nil { + predicates = append(predicates, orgsubscription.ProductTierEqualFold(*i.ProductTierEqualFold)) + } + if i.ProductTierContainsFold != nil { + predicates = append(predicates, orgsubscription.ProductTierContainsFold(*i.ProductTierContainsFold)) + } + if i.StripeProductTierID != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDEQ(*i.StripeProductTierID)) + } + if i.StripeProductTierIDNEQ != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDNEQ(*i.StripeProductTierIDNEQ)) + } + if len(i.StripeProductTierIDIn) > 0 { + predicates = append(predicates, orgsubscription.StripeProductTierIDIn(i.StripeProductTierIDIn...)) + } + if len(i.StripeProductTierIDNotIn) > 0 { + predicates = append(predicates, orgsubscription.StripeProductTierIDNotIn(i.StripeProductTierIDNotIn...)) + } + if i.StripeProductTierIDGT != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDGT(*i.StripeProductTierIDGT)) + } + if i.StripeProductTierIDGTE != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDGTE(*i.StripeProductTierIDGTE)) + } + if i.StripeProductTierIDLT != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDLT(*i.StripeProductTierIDLT)) + } + if i.StripeProductTierIDLTE != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDLTE(*i.StripeProductTierIDLTE)) + } + if i.StripeProductTierIDContains != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDContains(*i.StripeProductTierIDContains)) + } + if i.StripeProductTierIDHasPrefix != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDHasPrefix(*i.StripeProductTierIDHasPrefix)) + } + if i.StripeProductTierIDHasSuffix != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDHasSuffix(*i.StripeProductTierIDHasSuffix)) + } + if i.StripeProductTierIDIsNil { + predicates = append(predicates, orgsubscription.StripeProductTierIDIsNil()) + } + if i.StripeProductTierIDNotNil { + predicates = append(predicates, orgsubscription.StripeProductTierIDNotNil()) + } + if i.StripeProductTierIDEqualFold != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDEqualFold(*i.StripeProductTierIDEqualFold)) + } + if i.StripeProductTierIDContainsFold != nil { + predicates = append(predicates, orgsubscription.StripeProductTierIDContainsFold(*i.StripeProductTierIDContainsFold)) + } + if i.StripeSubscriptionStatus != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusEQ(*i.StripeSubscriptionStatus)) + } + if i.StripeSubscriptionStatusNEQ != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusNEQ(*i.StripeSubscriptionStatusNEQ)) + } + if len(i.StripeSubscriptionStatusIn) > 0 { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusIn(i.StripeSubscriptionStatusIn...)) + } + if len(i.StripeSubscriptionStatusNotIn) > 0 { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusNotIn(i.StripeSubscriptionStatusNotIn...)) + } + if i.StripeSubscriptionStatusGT != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusGT(*i.StripeSubscriptionStatusGT)) + } + if i.StripeSubscriptionStatusGTE != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusGTE(*i.StripeSubscriptionStatusGTE)) + } + if i.StripeSubscriptionStatusLT != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusLT(*i.StripeSubscriptionStatusLT)) + } + if i.StripeSubscriptionStatusLTE != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusLTE(*i.StripeSubscriptionStatusLTE)) + } + if i.StripeSubscriptionStatusContains != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusContains(*i.StripeSubscriptionStatusContains)) + } + if i.StripeSubscriptionStatusHasPrefix != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusHasPrefix(*i.StripeSubscriptionStatusHasPrefix)) + } + if i.StripeSubscriptionStatusHasSuffix != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusHasSuffix(*i.StripeSubscriptionStatusHasSuffix)) + } + if i.StripeSubscriptionStatusIsNil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusIsNil()) + } + if i.StripeSubscriptionStatusNotNil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusNotNil()) + } + if i.StripeSubscriptionStatusEqualFold != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusEqualFold(*i.StripeSubscriptionStatusEqualFold)) + } + if i.StripeSubscriptionStatusContainsFold != nil { + predicates = append(predicates, orgsubscription.StripeSubscriptionStatusContainsFold(*i.StripeSubscriptionStatusContainsFold)) + } + if i.Active != nil { + predicates = append(predicates, orgsubscription.ActiveEQ(*i.Active)) + } + if i.ActiveNEQ != nil { + predicates = append(predicates, orgsubscription.ActiveNEQ(*i.ActiveNEQ)) + } + if i.StripeCustomerID != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDEQ(*i.StripeCustomerID)) + } + if i.StripeCustomerIDNEQ != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDNEQ(*i.StripeCustomerIDNEQ)) + } + if len(i.StripeCustomerIDIn) > 0 { + predicates = append(predicates, orgsubscription.StripeCustomerIDIn(i.StripeCustomerIDIn...)) + } + if len(i.StripeCustomerIDNotIn) > 0 { + predicates = append(predicates, orgsubscription.StripeCustomerIDNotIn(i.StripeCustomerIDNotIn...)) + } + if i.StripeCustomerIDGT != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDGT(*i.StripeCustomerIDGT)) + } + if i.StripeCustomerIDGTE != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDGTE(*i.StripeCustomerIDGTE)) + } + if i.StripeCustomerIDLT != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDLT(*i.StripeCustomerIDLT)) + } + if i.StripeCustomerIDLTE != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDLTE(*i.StripeCustomerIDLTE)) + } + if i.StripeCustomerIDContains != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDContains(*i.StripeCustomerIDContains)) + } + if i.StripeCustomerIDHasPrefix != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDHasPrefix(*i.StripeCustomerIDHasPrefix)) + } + if i.StripeCustomerIDHasSuffix != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDHasSuffix(*i.StripeCustomerIDHasSuffix)) + } + if i.StripeCustomerIDIsNil { + predicates = append(predicates, orgsubscription.StripeCustomerIDIsNil()) + } + if i.StripeCustomerIDNotNil { + predicates = append(predicates, orgsubscription.StripeCustomerIDNotNil()) + } + if i.StripeCustomerIDEqualFold != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDEqualFold(*i.StripeCustomerIDEqualFold)) + } + if i.StripeCustomerIDContainsFold != nil { + predicates = append(predicates, orgsubscription.StripeCustomerIDContainsFold(*i.StripeCustomerIDContainsFold)) + } + if i.ExpiresAt != nil { + predicates = append(predicates, orgsubscription.ExpiresAtEQ(*i.ExpiresAt)) + } + if i.ExpiresAtNEQ != nil { + predicates = append(predicates, orgsubscription.ExpiresAtNEQ(*i.ExpiresAtNEQ)) + } + if len(i.ExpiresAtIn) > 0 { + predicates = append(predicates, orgsubscription.ExpiresAtIn(i.ExpiresAtIn...)) + } + if len(i.ExpiresAtNotIn) > 0 { + predicates = append(predicates, orgsubscription.ExpiresAtNotIn(i.ExpiresAtNotIn...)) + } + if i.ExpiresAtGT != nil { + predicates = append(predicates, orgsubscription.ExpiresAtGT(*i.ExpiresAtGT)) + } + if i.ExpiresAtGTE != nil { + predicates = append(predicates, orgsubscription.ExpiresAtGTE(*i.ExpiresAtGTE)) + } + if i.ExpiresAtLT != nil { + predicates = append(predicates, orgsubscription.ExpiresAtLT(*i.ExpiresAtLT)) + } + if i.ExpiresAtLTE != nil { + predicates = append(predicates, orgsubscription.ExpiresAtLTE(*i.ExpiresAtLTE)) + } + if i.ExpiresAtIsNil { + predicates = append(predicates, orgsubscription.ExpiresAtIsNil()) + } + if i.ExpiresAtNotNil { + predicates = append(predicates, orgsubscription.ExpiresAtNotNil()) + } + + if i.HasOwner != nil { + p := orgsubscription.HasOwner() + if !*i.HasOwner { + p = orgsubscription.Not(p) + } + predicates = append(predicates, p) + } + if len(i.HasOwnerWith) > 0 { + with := make([]predicate.Organization, 0, len(i.HasOwnerWith)) + for _, w := range i.HasOwnerWith { + p, err := w.P() + if err != nil { + return nil, fmt.Errorf("%w: field 'HasOwnerWith'", err) + } + with = append(with, p) + } + predicates = append(predicates, orgsubscription.HasOwnerWith(with...)) + } + switch len(predicates) { + case 0: + return nil, ErrEmptyOrgSubscriptionWhereInput + case 1: + return predicates[0], nil + default: + return orgsubscription.And(predicates...), nil + } +} + +// OrgSubscriptionHistoryWhereInput represents a where input for filtering OrgSubscriptionHistory queries. +type OrgSubscriptionHistoryWhereInput struct { + Predicates []predicate.OrgSubscriptionHistory `json:"-"` + Not *OrgSubscriptionHistoryWhereInput `json:"not,omitempty"` + Or []*OrgSubscriptionHistoryWhereInput `json:"or,omitempty"` + And []*OrgSubscriptionHistoryWhereInput `json:"and,omitempty"` + + // "id" field predicates. + ID *string `json:"id,omitempty"` + IDNEQ *string `json:"idNEQ,omitempty"` + IDIn []string `json:"idIn,omitempty"` + IDNotIn []string `json:"idNotIn,omitempty"` + IDGT *string `json:"idGT,omitempty"` + IDGTE *string `json:"idGTE,omitempty"` + IDLT *string `json:"idLT,omitempty"` + IDLTE *string `json:"idLTE,omitempty"` + IDEqualFold *string `json:"idEqualFold,omitempty"` + IDContainsFold *string `json:"idContainsFold,omitempty"` + + // "history_time" field predicates. + HistoryTime *time.Time `json:"historyTime,omitempty"` + HistoryTimeNEQ *time.Time `json:"historyTimeNEQ,omitempty"` + HistoryTimeIn []time.Time `json:"historyTimeIn,omitempty"` + HistoryTimeNotIn []time.Time `json:"historyTimeNotIn,omitempty"` + HistoryTimeGT *time.Time `json:"historyTimeGT,omitempty"` + HistoryTimeGTE *time.Time `json:"historyTimeGTE,omitempty"` + HistoryTimeLT *time.Time `json:"historyTimeLT,omitempty"` + HistoryTimeLTE *time.Time `json:"historyTimeLTE,omitempty"` + + // "ref" field predicates. + Ref *string `json:"ref,omitempty"` + RefNEQ *string `json:"refNEQ,omitempty"` + RefIn []string `json:"refIn,omitempty"` + RefNotIn []string `json:"refNotIn,omitempty"` + RefGT *string `json:"refGT,omitempty"` + RefGTE *string `json:"refGTE,omitempty"` + RefLT *string `json:"refLT,omitempty"` + RefLTE *string `json:"refLTE,omitempty"` + RefContains *string `json:"refContains,omitempty"` + RefHasPrefix *string `json:"refHasPrefix,omitempty"` + RefHasSuffix *string `json:"refHasSuffix,omitempty"` + RefIsNil bool `json:"refIsNil,omitempty"` + RefNotNil bool `json:"refNotNil,omitempty"` + RefEqualFold *string `json:"refEqualFold,omitempty"` + RefContainsFold *string `json:"refContainsFold,omitempty"` + + // "operation" field predicates. + Operation *history.OpType `json:"operation,omitempty"` + OperationNEQ *history.OpType `json:"operationNEQ,omitempty"` + OperationIn []history.OpType `json:"operationIn,omitempty"` + OperationNotIn []history.OpType `json:"operationNotIn,omitempty"` + + // "created_at" field predicates. + CreatedAt *time.Time `json:"createdAt,omitempty"` + CreatedAtNEQ *time.Time `json:"createdAtNEQ,omitempty"` + CreatedAtIn []time.Time `json:"createdAtIn,omitempty"` + CreatedAtNotIn []time.Time `json:"createdAtNotIn,omitempty"` + CreatedAtGT *time.Time `json:"createdAtGT,omitempty"` + CreatedAtGTE *time.Time `json:"createdAtGTE,omitempty"` + CreatedAtLT *time.Time `json:"createdAtLT,omitempty"` + CreatedAtLTE *time.Time `json:"createdAtLTE,omitempty"` + CreatedAtIsNil bool `json:"createdAtIsNil,omitempty"` + CreatedAtNotNil bool `json:"createdAtNotNil,omitempty"` + + // "updated_at" field predicates. + UpdatedAt *time.Time `json:"updatedAt,omitempty"` + UpdatedAtNEQ *time.Time `json:"updatedAtNEQ,omitempty"` + UpdatedAtIn []time.Time `json:"updatedAtIn,omitempty"` + UpdatedAtNotIn []time.Time `json:"updatedAtNotIn,omitempty"` + UpdatedAtGT *time.Time `json:"updatedAtGT,omitempty"` + UpdatedAtGTE *time.Time `json:"updatedAtGTE,omitempty"` + UpdatedAtLT *time.Time `json:"updatedAtLT,omitempty"` + UpdatedAtLTE *time.Time `json:"updatedAtLTE,omitempty"` + UpdatedAtIsNil bool `json:"updatedAtIsNil,omitempty"` + UpdatedAtNotNil bool `json:"updatedAtNotNil,omitempty"` + + // "created_by" field predicates. + CreatedBy *string `json:"createdBy,omitempty"` + CreatedByNEQ *string `json:"createdByNEQ,omitempty"` + CreatedByIn []string `json:"createdByIn,omitempty"` + CreatedByNotIn []string `json:"createdByNotIn,omitempty"` + CreatedByGT *string `json:"createdByGT,omitempty"` + CreatedByGTE *string `json:"createdByGTE,omitempty"` + CreatedByLT *string `json:"createdByLT,omitempty"` + CreatedByLTE *string `json:"createdByLTE,omitempty"` + CreatedByContains *string `json:"createdByContains,omitempty"` + CreatedByHasPrefix *string `json:"createdByHasPrefix,omitempty"` + CreatedByHasSuffix *string `json:"createdByHasSuffix,omitempty"` + CreatedByIsNil bool `json:"createdByIsNil,omitempty"` + CreatedByNotNil bool `json:"createdByNotNil,omitempty"` + CreatedByEqualFold *string `json:"createdByEqualFold,omitempty"` + CreatedByContainsFold *string `json:"createdByContainsFold,omitempty"` + + // "updated_by" field predicates. + UpdatedBy *string `json:"updatedBy,omitempty"` + UpdatedByNEQ *string `json:"updatedByNEQ,omitempty"` + UpdatedByIn []string `json:"updatedByIn,omitempty"` + UpdatedByNotIn []string `json:"updatedByNotIn,omitempty"` + UpdatedByGT *string `json:"updatedByGT,omitempty"` + UpdatedByGTE *string `json:"updatedByGTE,omitempty"` + UpdatedByLT *string `json:"updatedByLT,omitempty"` + UpdatedByLTE *string `json:"updatedByLTE,omitempty"` + UpdatedByContains *string `json:"updatedByContains,omitempty"` + UpdatedByHasPrefix *string `json:"updatedByHasPrefix,omitempty"` + UpdatedByHasSuffix *string `json:"updatedByHasSuffix,omitempty"` + UpdatedByIsNil bool `json:"updatedByIsNil,omitempty"` + UpdatedByNotNil bool `json:"updatedByNotNil,omitempty"` + UpdatedByEqualFold *string `json:"updatedByEqualFold,omitempty"` + UpdatedByContainsFold *string `json:"updatedByContainsFold,omitempty"` + + // "deleted_at" field predicates. + DeletedAt *time.Time `json:"deletedAt,omitempty"` + DeletedAtNEQ *time.Time `json:"deletedAtNEQ,omitempty"` + DeletedAtIn []time.Time `json:"deletedAtIn,omitempty"` + DeletedAtNotIn []time.Time `json:"deletedAtNotIn,omitempty"` + DeletedAtGT *time.Time `json:"deletedAtGT,omitempty"` + DeletedAtGTE *time.Time `json:"deletedAtGTE,omitempty"` + DeletedAtLT *time.Time `json:"deletedAtLT,omitempty"` + DeletedAtLTE *time.Time `json:"deletedAtLTE,omitempty"` + DeletedAtIsNil bool `json:"deletedAtIsNil,omitempty"` + DeletedAtNotNil bool `json:"deletedAtNotNil,omitempty"` + + // "deleted_by" field predicates. + DeletedBy *string `json:"deletedBy,omitempty"` + DeletedByNEQ *string `json:"deletedByNEQ,omitempty"` + DeletedByIn []string `json:"deletedByIn,omitempty"` + DeletedByNotIn []string `json:"deletedByNotIn,omitempty"` + DeletedByGT *string `json:"deletedByGT,omitempty"` + DeletedByGTE *string `json:"deletedByGTE,omitempty"` + DeletedByLT *string `json:"deletedByLT,omitempty"` + DeletedByLTE *string `json:"deletedByLTE,omitempty"` + DeletedByContains *string `json:"deletedByContains,omitempty"` + DeletedByHasPrefix *string `json:"deletedByHasPrefix,omitempty"` + DeletedByHasSuffix *string `json:"deletedByHasSuffix,omitempty"` + DeletedByIsNil bool `json:"deletedByIsNil,omitempty"` + DeletedByNotNil bool `json:"deletedByNotNil,omitempty"` + DeletedByEqualFold *string `json:"deletedByEqualFold,omitempty"` + DeletedByContainsFold *string `json:"deletedByContainsFold,omitempty"` + + // "owner_id" field predicates. + OwnerID *string `json:"ownerID,omitempty"` + OwnerIDNEQ *string `json:"ownerIDNEQ,omitempty"` + OwnerIDIn []string `json:"ownerIDIn,omitempty"` + OwnerIDNotIn []string `json:"ownerIDNotIn,omitempty"` + OwnerIDGT *string `json:"ownerIDGT,omitempty"` + OwnerIDGTE *string `json:"ownerIDGTE,omitempty"` + OwnerIDLT *string `json:"ownerIDLT,omitempty"` + OwnerIDLTE *string `json:"ownerIDLTE,omitempty"` + OwnerIDContains *string `json:"ownerIDContains,omitempty"` + OwnerIDHasPrefix *string `json:"ownerIDHasPrefix,omitempty"` + OwnerIDHasSuffix *string `json:"ownerIDHasSuffix,omitempty"` + OwnerIDIsNil bool `json:"ownerIDIsNil,omitempty"` + OwnerIDNotNil bool `json:"ownerIDNotNil,omitempty"` + OwnerIDEqualFold *string `json:"ownerIDEqualFold,omitempty"` + OwnerIDContainsFold *string `json:"ownerIDContainsFold,omitempty"` + + // "stripe_subscription_id" field predicates. + StripeSubscriptionID *string `json:"stripeSubscriptionID,omitempty"` + StripeSubscriptionIDNEQ *string `json:"stripeSubscriptionIDNEQ,omitempty"` + StripeSubscriptionIDIn []string `json:"stripeSubscriptionIDIn,omitempty"` + StripeSubscriptionIDNotIn []string `json:"stripeSubscriptionIDNotIn,omitempty"` + StripeSubscriptionIDGT *string `json:"stripeSubscriptionIDGT,omitempty"` + StripeSubscriptionIDGTE *string `json:"stripeSubscriptionIDGTE,omitempty"` + StripeSubscriptionIDLT *string `json:"stripeSubscriptionIDLT,omitempty"` + StripeSubscriptionIDLTE *string `json:"stripeSubscriptionIDLTE,omitempty"` + StripeSubscriptionIDContains *string `json:"stripeSubscriptionIDContains,omitempty"` + StripeSubscriptionIDHasPrefix *string `json:"stripeSubscriptionIDHasPrefix,omitempty"` + StripeSubscriptionIDHasSuffix *string `json:"stripeSubscriptionIDHasSuffix,omitempty"` + StripeSubscriptionIDIsNil bool `json:"stripeSubscriptionIDIsNil,omitempty"` + StripeSubscriptionIDNotNil bool `json:"stripeSubscriptionIDNotNil,omitempty"` + StripeSubscriptionIDEqualFold *string `json:"stripeSubscriptionIDEqualFold,omitempty"` + StripeSubscriptionIDContainsFold *string `json:"stripeSubscriptionIDContainsFold,omitempty"` + + // "product_tier" field predicates. + ProductTier *string `json:"productTier,omitempty"` + ProductTierNEQ *string `json:"productTierNEQ,omitempty"` + ProductTierIn []string `json:"productTierIn,omitempty"` + ProductTierNotIn []string `json:"productTierNotIn,omitempty"` + ProductTierGT *string `json:"productTierGT,omitempty"` + ProductTierGTE *string `json:"productTierGTE,omitempty"` + ProductTierLT *string `json:"productTierLT,omitempty"` + ProductTierLTE *string `json:"productTierLTE,omitempty"` + ProductTierContains *string `json:"productTierContains,omitempty"` + ProductTierHasPrefix *string `json:"productTierHasPrefix,omitempty"` + ProductTierHasSuffix *string `json:"productTierHasSuffix,omitempty"` + ProductTierIsNil bool `json:"productTierIsNil,omitempty"` + ProductTierNotNil bool `json:"productTierNotNil,omitempty"` + ProductTierEqualFold *string `json:"productTierEqualFold,omitempty"` + ProductTierContainsFold *string `json:"productTierContainsFold,omitempty"` + + // "stripe_product_tier_id" field predicates. + StripeProductTierID *string `json:"stripeProductTierID,omitempty"` + StripeProductTierIDNEQ *string `json:"stripeProductTierIDNEQ,omitempty"` + StripeProductTierIDIn []string `json:"stripeProductTierIDIn,omitempty"` + StripeProductTierIDNotIn []string `json:"stripeProductTierIDNotIn,omitempty"` + StripeProductTierIDGT *string `json:"stripeProductTierIDGT,omitempty"` + StripeProductTierIDGTE *string `json:"stripeProductTierIDGTE,omitempty"` + StripeProductTierIDLT *string `json:"stripeProductTierIDLT,omitempty"` + StripeProductTierIDLTE *string `json:"stripeProductTierIDLTE,omitempty"` + StripeProductTierIDContains *string `json:"stripeProductTierIDContains,omitempty"` + StripeProductTierIDHasPrefix *string `json:"stripeProductTierIDHasPrefix,omitempty"` + StripeProductTierIDHasSuffix *string `json:"stripeProductTierIDHasSuffix,omitempty"` + StripeProductTierIDIsNil bool `json:"stripeProductTierIDIsNil,omitempty"` + StripeProductTierIDNotNil bool `json:"stripeProductTierIDNotNil,omitempty"` + StripeProductTierIDEqualFold *string `json:"stripeProductTierIDEqualFold,omitempty"` + StripeProductTierIDContainsFold *string `json:"stripeProductTierIDContainsFold,omitempty"` + + // "stripe_subscription_status" field predicates. + StripeSubscriptionStatus *string `json:"stripeSubscriptionStatus,omitempty"` + StripeSubscriptionStatusNEQ *string `json:"stripeSubscriptionStatusNEQ,omitempty"` + StripeSubscriptionStatusIn []string `json:"stripeSubscriptionStatusIn,omitempty"` + StripeSubscriptionStatusNotIn []string `json:"stripeSubscriptionStatusNotIn,omitempty"` + StripeSubscriptionStatusGT *string `json:"stripeSubscriptionStatusGT,omitempty"` + StripeSubscriptionStatusGTE *string `json:"stripeSubscriptionStatusGTE,omitempty"` + StripeSubscriptionStatusLT *string `json:"stripeSubscriptionStatusLT,omitempty"` + StripeSubscriptionStatusLTE *string `json:"stripeSubscriptionStatusLTE,omitempty"` + StripeSubscriptionStatusContains *string `json:"stripeSubscriptionStatusContains,omitempty"` + StripeSubscriptionStatusHasPrefix *string `json:"stripeSubscriptionStatusHasPrefix,omitempty"` + StripeSubscriptionStatusHasSuffix *string `json:"stripeSubscriptionStatusHasSuffix,omitempty"` + StripeSubscriptionStatusIsNil bool `json:"stripeSubscriptionStatusIsNil,omitempty"` + StripeSubscriptionStatusNotNil bool `json:"stripeSubscriptionStatusNotNil,omitempty"` + StripeSubscriptionStatusEqualFold *string `json:"stripeSubscriptionStatusEqualFold,omitempty"` + StripeSubscriptionStatusContainsFold *string `json:"stripeSubscriptionStatusContainsFold,omitempty"` + + // "active" field predicates. + Active *bool `json:"active,omitempty"` + ActiveNEQ *bool `json:"activeNEQ,omitempty"` + + // "stripe_customer_id" field predicates. + StripeCustomerID *string `json:"stripeCustomerID,omitempty"` + StripeCustomerIDNEQ *string `json:"stripeCustomerIDNEQ,omitempty"` + StripeCustomerIDIn []string `json:"stripeCustomerIDIn,omitempty"` + StripeCustomerIDNotIn []string `json:"stripeCustomerIDNotIn,omitempty"` + StripeCustomerIDGT *string `json:"stripeCustomerIDGT,omitempty"` + StripeCustomerIDGTE *string `json:"stripeCustomerIDGTE,omitempty"` + StripeCustomerIDLT *string `json:"stripeCustomerIDLT,omitempty"` + StripeCustomerIDLTE *string `json:"stripeCustomerIDLTE,omitempty"` + StripeCustomerIDContains *string `json:"stripeCustomerIDContains,omitempty"` + StripeCustomerIDHasPrefix *string `json:"stripeCustomerIDHasPrefix,omitempty"` + StripeCustomerIDHasSuffix *string `json:"stripeCustomerIDHasSuffix,omitempty"` + StripeCustomerIDIsNil bool `json:"stripeCustomerIDIsNil,omitempty"` + StripeCustomerIDNotNil bool `json:"stripeCustomerIDNotNil,omitempty"` + StripeCustomerIDEqualFold *string `json:"stripeCustomerIDEqualFold,omitempty"` + StripeCustomerIDContainsFold *string `json:"stripeCustomerIDContainsFold,omitempty"` + + // "expires_at" field predicates. + ExpiresAt *time.Time `json:"expiresAt,omitempty"` + ExpiresAtNEQ *time.Time `json:"expiresAtNEQ,omitempty"` + ExpiresAtIn []time.Time `json:"expiresAtIn,omitempty"` + ExpiresAtNotIn []time.Time `json:"expiresAtNotIn,omitempty"` + ExpiresAtGT *time.Time `json:"expiresAtGT,omitempty"` + ExpiresAtGTE *time.Time `json:"expiresAtGTE,omitempty"` + ExpiresAtLT *time.Time `json:"expiresAtLT,omitempty"` + ExpiresAtLTE *time.Time `json:"expiresAtLTE,omitempty"` + ExpiresAtIsNil bool `json:"expiresAtIsNil,omitempty"` + ExpiresAtNotNil bool `json:"expiresAtNotNil,omitempty"` +} + +// AddPredicates adds custom predicates to the where input to be used during the filtering phase. +func (i *OrgSubscriptionHistoryWhereInput) AddPredicates(predicates ...predicate.OrgSubscriptionHistory) { + i.Predicates = append(i.Predicates, predicates...) +} + +// Filter applies the OrgSubscriptionHistoryWhereInput filter on the OrgSubscriptionHistoryQuery builder. +func (i *OrgSubscriptionHistoryWhereInput) Filter(q *OrgSubscriptionHistoryQuery) (*OrgSubscriptionHistoryQuery, error) { + if i == nil { + return q, nil + } + p, err := i.P() + if err != nil { + if err == ErrEmptyOrgSubscriptionHistoryWhereInput { + return q, nil + } + return nil, err + } + return q.Where(p), nil +} + +// ErrEmptyOrgSubscriptionHistoryWhereInput is returned in case the OrgSubscriptionHistoryWhereInput is empty. +var ErrEmptyOrgSubscriptionHistoryWhereInput = errors.New("generated: empty predicate OrgSubscriptionHistoryWhereInput") + +// P returns a predicate for filtering orgsubscriptionhistories. +// An error is returned if the input is empty or invalid. +func (i *OrgSubscriptionHistoryWhereInput) P() (predicate.OrgSubscriptionHistory, error) { + var predicates []predicate.OrgSubscriptionHistory + if i.Not != nil { + p, err := i.Not.P() + if err != nil { + return nil, fmt.Errorf("%w: field 'not'", err) + } + predicates = append(predicates, orgsubscriptionhistory.Not(p)) + } + switch n := len(i.Or); { + case n == 1: + p, err := i.Or[0].P() + if err != nil { + return nil, fmt.Errorf("%w: field 'or'", err) + } + predicates = append(predicates, p) + case n > 1: + or := make([]predicate.OrgSubscriptionHistory, 0, n) + for _, w := range i.Or { + p, err := w.P() + if err != nil { + return nil, fmt.Errorf("%w: field 'or'", err) + } + or = append(or, p) + } + predicates = append(predicates, orgsubscriptionhistory.Or(or...)) + } + switch n := len(i.And); { + case n == 1: + p, err := i.And[0].P() + if err != nil { + return nil, fmt.Errorf("%w: field 'and'", err) + } + predicates = append(predicates, p) + case n > 1: + and := make([]predicate.OrgSubscriptionHistory, 0, n) + for _, w := range i.And { + p, err := w.P() + if err != nil { + return nil, fmt.Errorf("%w: field 'and'", err) + } + and = append(and, p) + } + predicates = append(predicates, orgsubscriptionhistory.And(and...)) + } + predicates = append(predicates, i.Predicates...) + if i.ID != nil { + predicates = append(predicates, orgsubscriptionhistory.IDEQ(*i.ID)) + } + if i.IDNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.IDNEQ(*i.IDNEQ)) + } + if len(i.IDIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.IDIn(i.IDIn...)) + } + if len(i.IDNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.IDNotIn(i.IDNotIn...)) + } + if i.IDGT != nil { + predicates = append(predicates, orgsubscriptionhistory.IDGT(*i.IDGT)) + } + if i.IDGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.IDGTE(*i.IDGTE)) + } + if i.IDLT != nil { + predicates = append(predicates, orgsubscriptionhistory.IDLT(*i.IDLT)) + } + if i.IDLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.IDLTE(*i.IDLTE)) + } + if i.IDEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.IDEqualFold(*i.IDEqualFold)) + } + if i.IDContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.IDContainsFold(*i.IDContainsFold)) + } + if i.HistoryTime != nil { + predicates = append(predicates, orgsubscriptionhistory.HistoryTimeEQ(*i.HistoryTime)) + } + if i.HistoryTimeNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.HistoryTimeNEQ(*i.HistoryTimeNEQ)) + } + if len(i.HistoryTimeIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.HistoryTimeIn(i.HistoryTimeIn...)) + } + if len(i.HistoryTimeNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.HistoryTimeNotIn(i.HistoryTimeNotIn...)) + } + if i.HistoryTimeGT != nil { + predicates = append(predicates, orgsubscriptionhistory.HistoryTimeGT(*i.HistoryTimeGT)) + } + if i.HistoryTimeGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.HistoryTimeGTE(*i.HistoryTimeGTE)) + } + if i.HistoryTimeLT != nil { + predicates = append(predicates, orgsubscriptionhistory.HistoryTimeLT(*i.HistoryTimeLT)) + } + if i.HistoryTimeLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.HistoryTimeLTE(*i.HistoryTimeLTE)) + } + if i.Ref != nil { + predicates = append(predicates, orgsubscriptionhistory.RefEQ(*i.Ref)) + } + if i.RefNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.RefNEQ(*i.RefNEQ)) + } + if len(i.RefIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.RefIn(i.RefIn...)) + } + if len(i.RefNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.RefNotIn(i.RefNotIn...)) + } + if i.RefGT != nil { + predicates = append(predicates, orgsubscriptionhistory.RefGT(*i.RefGT)) + } + if i.RefGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.RefGTE(*i.RefGTE)) + } + if i.RefLT != nil { + predicates = append(predicates, orgsubscriptionhistory.RefLT(*i.RefLT)) + } + if i.RefLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.RefLTE(*i.RefLTE)) + } + if i.RefContains != nil { + predicates = append(predicates, orgsubscriptionhistory.RefContains(*i.RefContains)) + } + if i.RefHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.RefHasPrefix(*i.RefHasPrefix)) + } + if i.RefHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.RefHasSuffix(*i.RefHasSuffix)) + } + if i.RefIsNil { + predicates = append(predicates, orgsubscriptionhistory.RefIsNil()) + } + if i.RefNotNil { + predicates = append(predicates, orgsubscriptionhistory.RefNotNil()) + } + if i.RefEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.RefEqualFold(*i.RefEqualFold)) + } + if i.RefContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.RefContainsFold(*i.RefContainsFold)) + } + if i.Operation != nil { + predicates = append(predicates, orgsubscriptionhistory.OperationEQ(*i.Operation)) + } + if i.OperationNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.OperationNEQ(*i.OperationNEQ)) + } + if len(i.OperationIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.OperationIn(i.OperationIn...)) + } + if len(i.OperationNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.OperationNotIn(i.OperationNotIn...)) + } + if i.CreatedAt != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtEQ(*i.CreatedAt)) + } + if i.CreatedAtNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtNEQ(*i.CreatedAtNEQ)) + } + if len(i.CreatedAtIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtIn(i.CreatedAtIn...)) + } + if len(i.CreatedAtNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtNotIn(i.CreatedAtNotIn...)) + } + if i.CreatedAtGT != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtGT(*i.CreatedAtGT)) + } + if i.CreatedAtGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtGTE(*i.CreatedAtGTE)) + } + if i.CreatedAtLT != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtLT(*i.CreatedAtLT)) + } + if i.CreatedAtLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtLTE(*i.CreatedAtLTE)) + } + if i.CreatedAtIsNil { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtIsNil()) + } + if i.CreatedAtNotNil { + predicates = append(predicates, orgsubscriptionhistory.CreatedAtNotNil()) + } + if i.UpdatedAt != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtEQ(*i.UpdatedAt)) + } + if i.UpdatedAtNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtNEQ(*i.UpdatedAtNEQ)) + } + if len(i.UpdatedAtIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtIn(i.UpdatedAtIn...)) + } + if len(i.UpdatedAtNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtNotIn(i.UpdatedAtNotIn...)) + } + if i.UpdatedAtGT != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtGT(*i.UpdatedAtGT)) + } + if i.UpdatedAtGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtGTE(*i.UpdatedAtGTE)) + } + if i.UpdatedAtLT != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtLT(*i.UpdatedAtLT)) + } + if i.UpdatedAtLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtLTE(*i.UpdatedAtLTE)) + } + if i.UpdatedAtIsNil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtIsNil()) + } + if i.UpdatedAtNotNil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedAtNotNil()) + } + if i.CreatedBy != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByEQ(*i.CreatedBy)) + } + if i.CreatedByNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByNEQ(*i.CreatedByNEQ)) + } + if len(i.CreatedByIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.CreatedByIn(i.CreatedByIn...)) + } + if len(i.CreatedByNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.CreatedByNotIn(i.CreatedByNotIn...)) + } + if i.CreatedByGT != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByGT(*i.CreatedByGT)) + } + if i.CreatedByGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByGTE(*i.CreatedByGTE)) + } + if i.CreatedByLT != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByLT(*i.CreatedByLT)) + } + if i.CreatedByLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByLTE(*i.CreatedByLTE)) + } + if i.CreatedByContains != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByContains(*i.CreatedByContains)) + } + if i.CreatedByHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByHasPrefix(*i.CreatedByHasPrefix)) + } + if i.CreatedByHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByHasSuffix(*i.CreatedByHasSuffix)) + } + if i.CreatedByIsNil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByIsNil()) + } + if i.CreatedByNotNil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByNotNil()) + } + if i.CreatedByEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByEqualFold(*i.CreatedByEqualFold)) + } + if i.CreatedByContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.CreatedByContainsFold(*i.CreatedByContainsFold)) + } + if i.UpdatedBy != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByEQ(*i.UpdatedBy)) + } + if i.UpdatedByNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByNEQ(*i.UpdatedByNEQ)) + } + if len(i.UpdatedByIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByIn(i.UpdatedByIn...)) + } + if len(i.UpdatedByNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByNotIn(i.UpdatedByNotIn...)) + } + if i.UpdatedByGT != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByGT(*i.UpdatedByGT)) + } + if i.UpdatedByGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByGTE(*i.UpdatedByGTE)) + } + if i.UpdatedByLT != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByLT(*i.UpdatedByLT)) + } + if i.UpdatedByLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByLTE(*i.UpdatedByLTE)) + } + if i.UpdatedByContains != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByContains(*i.UpdatedByContains)) + } + if i.UpdatedByHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByHasPrefix(*i.UpdatedByHasPrefix)) + } + if i.UpdatedByHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByHasSuffix(*i.UpdatedByHasSuffix)) + } + if i.UpdatedByIsNil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByIsNil()) + } + if i.UpdatedByNotNil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByNotNil()) + } + if i.UpdatedByEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByEqualFold(*i.UpdatedByEqualFold)) + } + if i.UpdatedByContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.UpdatedByContainsFold(*i.UpdatedByContainsFold)) + } + if i.DeletedAt != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtEQ(*i.DeletedAt)) + } + if i.DeletedAtNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtNEQ(*i.DeletedAtNEQ)) + } + if len(i.DeletedAtIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtIn(i.DeletedAtIn...)) + } + if len(i.DeletedAtNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtNotIn(i.DeletedAtNotIn...)) + } + if i.DeletedAtGT != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtGT(*i.DeletedAtGT)) + } + if i.DeletedAtGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtGTE(*i.DeletedAtGTE)) + } + if i.DeletedAtLT != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtLT(*i.DeletedAtLT)) + } + if i.DeletedAtLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtLTE(*i.DeletedAtLTE)) + } + if i.DeletedAtIsNil { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtIsNil()) + } + if i.DeletedAtNotNil { + predicates = append(predicates, orgsubscriptionhistory.DeletedAtNotNil()) + } + if i.DeletedBy != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByEQ(*i.DeletedBy)) + } + if i.DeletedByNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByNEQ(*i.DeletedByNEQ)) + } + if len(i.DeletedByIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.DeletedByIn(i.DeletedByIn...)) + } + if len(i.DeletedByNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.DeletedByNotIn(i.DeletedByNotIn...)) + } + if i.DeletedByGT != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByGT(*i.DeletedByGT)) + } + if i.DeletedByGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByGTE(*i.DeletedByGTE)) + } + if i.DeletedByLT != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByLT(*i.DeletedByLT)) + } + if i.DeletedByLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByLTE(*i.DeletedByLTE)) + } + if i.DeletedByContains != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByContains(*i.DeletedByContains)) + } + if i.DeletedByHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByHasPrefix(*i.DeletedByHasPrefix)) + } + if i.DeletedByHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByHasSuffix(*i.DeletedByHasSuffix)) + } + if i.DeletedByIsNil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByIsNil()) + } + if i.DeletedByNotNil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByNotNil()) + } + if i.DeletedByEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByEqualFold(*i.DeletedByEqualFold)) + } + if i.DeletedByContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.DeletedByContainsFold(*i.DeletedByContainsFold)) + } + if i.OwnerID != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDEQ(*i.OwnerID)) + } + if i.OwnerIDNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDNEQ(*i.OwnerIDNEQ)) + } + if len(i.OwnerIDIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDIn(i.OwnerIDIn...)) + } + if len(i.OwnerIDNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDNotIn(i.OwnerIDNotIn...)) + } + if i.OwnerIDGT != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDGT(*i.OwnerIDGT)) + } + if i.OwnerIDGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDGTE(*i.OwnerIDGTE)) + } + if i.OwnerIDLT != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDLT(*i.OwnerIDLT)) + } + if i.OwnerIDLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDLTE(*i.OwnerIDLTE)) + } + if i.OwnerIDContains != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDContains(*i.OwnerIDContains)) + } + if i.OwnerIDHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDHasPrefix(*i.OwnerIDHasPrefix)) + } + if i.OwnerIDHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDHasSuffix(*i.OwnerIDHasSuffix)) + } + if i.OwnerIDIsNil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDIsNil()) + } + if i.OwnerIDNotNil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDNotNil()) + } + if i.OwnerIDEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDEqualFold(*i.OwnerIDEqualFold)) + } + if i.OwnerIDContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.OwnerIDContainsFold(*i.OwnerIDContainsFold)) + } + if i.StripeSubscriptionID != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDEQ(*i.StripeSubscriptionID)) + } + if i.StripeSubscriptionIDNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDNEQ(*i.StripeSubscriptionIDNEQ)) + } + if len(i.StripeSubscriptionIDIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDIn(i.StripeSubscriptionIDIn...)) + } + if len(i.StripeSubscriptionIDNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDNotIn(i.StripeSubscriptionIDNotIn...)) + } + if i.StripeSubscriptionIDGT != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDGT(*i.StripeSubscriptionIDGT)) + } + if i.StripeSubscriptionIDGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDGTE(*i.StripeSubscriptionIDGTE)) + } + if i.StripeSubscriptionIDLT != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDLT(*i.StripeSubscriptionIDLT)) + } + if i.StripeSubscriptionIDLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDLTE(*i.StripeSubscriptionIDLTE)) + } + if i.StripeSubscriptionIDContains != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDContains(*i.StripeSubscriptionIDContains)) + } + if i.StripeSubscriptionIDHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDHasPrefix(*i.StripeSubscriptionIDHasPrefix)) + } + if i.StripeSubscriptionIDHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDHasSuffix(*i.StripeSubscriptionIDHasSuffix)) + } + if i.StripeSubscriptionIDIsNil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDIsNil()) + } + if i.StripeSubscriptionIDNotNil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDNotNil()) + } + if i.StripeSubscriptionIDEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDEqualFold(*i.StripeSubscriptionIDEqualFold)) + } + if i.StripeSubscriptionIDContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionIDContainsFold(*i.StripeSubscriptionIDContainsFold)) + } + if i.ProductTier != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierEQ(*i.ProductTier)) + } + if i.ProductTierNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierNEQ(*i.ProductTierNEQ)) + } + if len(i.ProductTierIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.ProductTierIn(i.ProductTierIn...)) + } + if len(i.ProductTierNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.ProductTierNotIn(i.ProductTierNotIn...)) + } + if i.ProductTierGT != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierGT(*i.ProductTierGT)) + } + if i.ProductTierGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierGTE(*i.ProductTierGTE)) + } + if i.ProductTierLT != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierLT(*i.ProductTierLT)) + } + if i.ProductTierLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierLTE(*i.ProductTierLTE)) + } + if i.ProductTierContains != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierContains(*i.ProductTierContains)) + } + if i.ProductTierHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierHasPrefix(*i.ProductTierHasPrefix)) + } + if i.ProductTierHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierHasSuffix(*i.ProductTierHasSuffix)) + } + if i.ProductTierIsNil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierIsNil()) + } + if i.ProductTierNotNil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierNotNil()) + } + if i.ProductTierEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierEqualFold(*i.ProductTierEqualFold)) + } + if i.ProductTierContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.ProductTierContainsFold(*i.ProductTierContainsFold)) + } + if i.StripeProductTierID != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDEQ(*i.StripeProductTierID)) + } + if i.StripeProductTierIDNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDNEQ(*i.StripeProductTierIDNEQ)) + } + if len(i.StripeProductTierIDIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDIn(i.StripeProductTierIDIn...)) + } + if len(i.StripeProductTierIDNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDNotIn(i.StripeProductTierIDNotIn...)) + } + if i.StripeProductTierIDGT != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDGT(*i.StripeProductTierIDGT)) + } + if i.StripeProductTierIDGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDGTE(*i.StripeProductTierIDGTE)) + } + if i.StripeProductTierIDLT != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDLT(*i.StripeProductTierIDLT)) + } + if i.StripeProductTierIDLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDLTE(*i.StripeProductTierIDLTE)) + } + if i.StripeProductTierIDContains != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDContains(*i.StripeProductTierIDContains)) + } + if i.StripeProductTierIDHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDHasPrefix(*i.StripeProductTierIDHasPrefix)) + } + if i.StripeProductTierIDHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDHasSuffix(*i.StripeProductTierIDHasSuffix)) + } + if i.StripeProductTierIDIsNil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDIsNil()) + } + if i.StripeProductTierIDNotNil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDNotNil()) + } + if i.StripeProductTierIDEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDEqualFold(*i.StripeProductTierIDEqualFold)) + } + if i.StripeProductTierIDContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeProductTierIDContainsFold(*i.StripeProductTierIDContainsFold)) + } + if i.StripeSubscriptionStatus != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusEQ(*i.StripeSubscriptionStatus)) + } + if i.StripeSubscriptionStatusNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusNEQ(*i.StripeSubscriptionStatusNEQ)) + } + if len(i.StripeSubscriptionStatusIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusIn(i.StripeSubscriptionStatusIn...)) + } + if len(i.StripeSubscriptionStatusNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusNotIn(i.StripeSubscriptionStatusNotIn...)) + } + if i.StripeSubscriptionStatusGT != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusGT(*i.StripeSubscriptionStatusGT)) + } + if i.StripeSubscriptionStatusGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusGTE(*i.StripeSubscriptionStatusGTE)) + } + if i.StripeSubscriptionStatusLT != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusLT(*i.StripeSubscriptionStatusLT)) + } + if i.StripeSubscriptionStatusLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusLTE(*i.StripeSubscriptionStatusLTE)) + } + if i.StripeSubscriptionStatusContains != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusContains(*i.StripeSubscriptionStatusContains)) + } + if i.StripeSubscriptionStatusHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusHasPrefix(*i.StripeSubscriptionStatusHasPrefix)) + } + if i.StripeSubscriptionStatusHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusHasSuffix(*i.StripeSubscriptionStatusHasSuffix)) + } + if i.StripeSubscriptionStatusIsNil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusIsNil()) + } + if i.StripeSubscriptionStatusNotNil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusNotNil()) + } + if i.StripeSubscriptionStatusEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusEqualFold(*i.StripeSubscriptionStatusEqualFold)) + } + if i.StripeSubscriptionStatusContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeSubscriptionStatusContainsFold(*i.StripeSubscriptionStatusContainsFold)) + } + if i.Active != nil { + predicates = append(predicates, orgsubscriptionhistory.ActiveEQ(*i.Active)) + } + if i.ActiveNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.ActiveNEQ(*i.ActiveNEQ)) + } + if i.StripeCustomerID != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDEQ(*i.StripeCustomerID)) + } + if i.StripeCustomerIDNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDNEQ(*i.StripeCustomerIDNEQ)) + } + if len(i.StripeCustomerIDIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDIn(i.StripeCustomerIDIn...)) + } + if len(i.StripeCustomerIDNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDNotIn(i.StripeCustomerIDNotIn...)) + } + if i.StripeCustomerIDGT != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDGT(*i.StripeCustomerIDGT)) + } + if i.StripeCustomerIDGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDGTE(*i.StripeCustomerIDGTE)) + } + if i.StripeCustomerIDLT != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDLT(*i.StripeCustomerIDLT)) + } + if i.StripeCustomerIDLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDLTE(*i.StripeCustomerIDLTE)) + } + if i.StripeCustomerIDContains != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDContains(*i.StripeCustomerIDContains)) + } + if i.StripeCustomerIDHasPrefix != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDHasPrefix(*i.StripeCustomerIDHasPrefix)) + } + if i.StripeCustomerIDHasSuffix != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDHasSuffix(*i.StripeCustomerIDHasSuffix)) + } + if i.StripeCustomerIDIsNil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDIsNil()) + } + if i.StripeCustomerIDNotNil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDNotNil()) + } + if i.StripeCustomerIDEqualFold != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDEqualFold(*i.StripeCustomerIDEqualFold)) + } + if i.StripeCustomerIDContainsFold != nil { + predicates = append(predicates, orgsubscriptionhistory.StripeCustomerIDContainsFold(*i.StripeCustomerIDContainsFold)) + } + if i.ExpiresAt != nil { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtEQ(*i.ExpiresAt)) + } + if i.ExpiresAtNEQ != nil { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtNEQ(*i.ExpiresAtNEQ)) + } + if len(i.ExpiresAtIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtIn(i.ExpiresAtIn...)) + } + if len(i.ExpiresAtNotIn) > 0 { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtNotIn(i.ExpiresAtNotIn...)) + } + if i.ExpiresAtGT != nil { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtGT(*i.ExpiresAtGT)) + } + if i.ExpiresAtGTE != nil { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtGTE(*i.ExpiresAtGTE)) + } + if i.ExpiresAtLT != nil { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtLT(*i.ExpiresAtLT)) + } + if i.ExpiresAtLTE != nil { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtLTE(*i.ExpiresAtLTE)) + } + if i.ExpiresAtIsNil { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtIsNil()) + } + if i.ExpiresAtNotNil { + predicates = append(predicates, orgsubscriptionhistory.ExpiresAtNotNil()) + } + + switch len(predicates) { + case 0: + return nil, ErrEmptyOrgSubscriptionHistoryWhereInput + case 1: + return predicates[0], nil + default: + return orgsubscriptionhistory.And(predicates...), nil + } +} + // OrganizationWhereInput represents a where input for filtering Organization queries. type OrganizationWhereInput struct { Predicates []predicate.Organization `json:"-"` @@ -43602,6 +45476,10 @@ type OrganizationWhereInput struct { HasEntitlements *bool `json:"hasEntitlements,omitempty"` HasEntitlementsWith []*EntitlementWhereInput `json:"hasEntitlementsWith,omitempty"` + // "orgsubscriptions" edge predicates. + HasOrgsubscriptions *bool `json:"hasOrgsubscriptions,omitempty"` + HasOrgsubscriptionsWith []*OrgSubscriptionWhereInput `json:"hasOrgsubscriptionsWith,omitempty"` + // "organization_entitlement" edge predicates. HasOrganizationEntitlement *bool `json:"hasOrganizationEntitlement,omitempty"` HasOrganizationEntitlementWith []*EntitlementWhereInput `json:"hasOrganizationEntitlementWith,omitempty"` @@ -44489,6 +46367,24 @@ func (i *OrganizationWhereInput) P() (predicate.Organization, error) { } predicates = append(predicates, organization.HasEntitlementsWith(with...)) } + if i.HasOrgsubscriptions != nil { + p := organization.HasOrgsubscriptions() + if !*i.HasOrgsubscriptions { + p = organization.Not(p) + } + predicates = append(predicates, p) + } + if len(i.HasOrgsubscriptionsWith) > 0 { + with := make([]predicate.OrgSubscription, 0, len(i.HasOrgsubscriptionsWith)) + for _, w := range i.HasOrgsubscriptionsWith { + p, err := w.P() + if err != nil { + return nil, fmt.Errorf("%w: field 'HasOrgsubscriptionsWith'", err) + } + with = append(with, p) + } + predicates = append(predicates, organization.HasOrgsubscriptionsWith(with...)) + } if i.HasOrganizationEntitlement != nil { p := organization.HasOrganizationEntitlement() if !*i.HasOrganizationEntitlement { diff --git a/internal/ent/generated/history_client.go b/internal/ent/generated/history_client.go index fe780ad5..8ec6b179 100644 --- a/internal/ent/generated/history_client.go +++ b/internal/ent/generated/history_client.go @@ -77,6 +77,9 @@ func (c *Client) WithHistory() { for _, hook := range history.HistoryHooks[*OrgMembershipMutation]() { c.OrgMembership.Use(hook) } + for _, hook := range history.HistoryHooks[*OrgSubscriptionMutation]() { + c.OrgSubscription.Use(hook) + } for _, hook := range history.HistoryHooks[*OrganizationMutation]() { c.Organization.Use(hook) } diff --git a/internal/ent/generated/history_from_mutation.go b/internal/ent/generated/history_from_mutation.go index 05d13326..9a523e32 100644 --- a/internal/ent/generated/history_from_mutation.go +++ b/internal/ent/generated/history_from_mutation.go @@ -5671,6 +5671,279 @@ func (m *OrgMembershipMutation) CreateHistoryFromDelete(ctx context.Context) err return nil } +func (m *OrgSubscriptionMutation) CreateHistoryFromCreate(ctx context.Context) error { + client := m.Client() + + id, ok := m.ID() + if !ok { + return idNotFoundError + } + + create := client.OrgSubscriptionHistory.Create() + + create = create. + SetOperation(EntOpToHistoryOp(m.Op())). + SetHistoryTime(time.Now()). + SetRef(id) + + if createdAt, exists := m.CreatedAt(); exists { + create = create.SetCreatedAt(createdAt) + } + + if updatedAt, exists := m.UpdatedAt(); exists { + create = create.SetUpdatedAt(updatedAt) + } + + if createdBy, exists := m.CreatedBy(); exists { + create = create.SetCreatedBy(createdBy) + } + + if updatedBy, exists := m.UpdatedBy(); exists { + create = create.SetUpdatedBy(updatedBy) + } + + if mappingID, exists := m.MappingID(); exists { + create = create.SetMappingID(mappingID) + } + + if tags, exists := m.Tags(); exists { + create = create.SetTags(tags) + } + + if deletedAt, exists := m.DeletedAt(); exists { + create = create.SetDeletedAt(deletedAt) + } + + if deletedBy, exists := m.DeletedBy(); exists { + create = create.SetDeletedBy(deletedBy) + } + + if ownerID, exists := m.OwnerID(); exists { + create = create.SetOwnerID(ownerID) + } + + if stripeSubscriptionID, exists := m.StripeSubscriptionID(); exists { + create = create.SetStripeSubscriptionID(stripeSubscriptionID) + } + + if productTier, exists := m.ProductTier(); exists { + create = create.SetProductTier(productTier) + } + + if stripeProductTierID, exists := m.StripeProductTierID(); exists { + create = create.SetStripeProductTierID(stripeProductTierID) + } + + if stripeSubscriptionStatus, exists := m.StripeSubscriptionStatus(); exists { + create = create.SetStripeSubscriptionStatus(stripeSubscriptionStatus) + } + + if active, exists := m.Active(); exists { + create = create.SetActive(active) + } + + if stripeCustomerID, exists := m.StripeCustomerID(); exists { + create = create.SetStripeCustomerID(stripeCustomerID) + } + + if expiresAt, exists := m.ExpiresAt(); exists { + create = create.SetNillableExpiresAt(&expiresAt) + } + + if features, exists := m.Features(); exists { + create = create.SetFeatures(features) + } + + _, err := create.Save(ctx) + + return err +} + +func (m *OrgSubscriptionMutation) CreateHistoryFromUpdate(ctx context.Context) error { + // check for soft delete operation and delete instead + if entx.CheckIsSoftDelete(ctx) { + return m.CreateHistoryFromDelete(ctx) + } + client := m.Client() + + ids, err := m.IDs(ctx) + if err != nil { + return fmt.Errorf("getting ids: %w", err) + } + + for _, id := range ids { + orgsubscription, err := client.OrgSubscription.Get(ctx, id) + if err != nil { + return err + } + + create := client.OrgSubscriptionHistory.Create() + + create = create. + SetOperation(EntOpToHistoryOp(m.Op())). + SetHistoryTime(time.Now()). + SetRef(id) + + if createdAt, exists := m.CreatedAt(); exists { + create = create.SetCreatedAt(createdAt) + } else { + create = create.SetCreatedAt(orgsubscription.CreatedAt) + } + + if updatedAt, exists := m.UpdatedAt(); exists { + create = create.SetUpdatedAt(updatedAt) + } else { + create = create.SetUpdatedAt(orgsubscription.UpdatedAt) + } + + if createdBy, exists := m.CreatedBy(); exists { + create = create.SetCreatedBy(createdBy) + } else { + create = create.SetCreatedBy(orgsubscription.CreatedBy) + } + + if updatedBy, exists := m.UpdatedBy(); exists { + create = create.SetUpdatedBy(updatedBy) + } else { + create = create.SetUpdatedBy(orgsubscription.UpdatedBy) + } + + if mappingID, exists := m.MappingID(); exists { + create = create.SetMappingID(mappingID) + } else { + create = create.SetMappingID(orgsubscription.MappingID) + } + + if tags, exists := m.Tags(); exists { + create = create.SetTags(tags) + } else { + create = create.SetTags(orgsubscription.Tags) + } + + if deletedAt, exists := m.DeletedAt(); exists { + create = create.SetDeletedAt(deletedAt) + } else { + create = create.SetDeletedAt(orgsubscription.DeletedAt) + } + + if deletedBy, exists := m.DeletedBy(); exists { + create = create.SetDeletedBy(deletedBy) + } else { + create = create.SetDeletedBy(orgsubscription.DeletedBy) + } + + if ownerID, exists := m.OwnerID(); exists { + create = create.SetOwnerID(ownerID) + } else { + create = create.SetOwnerID(orgsubscription.OwnerID) + } + + if stripeSubscriptionID, exists := m.StripeSubscriptionID(); exists { + create = create.SetStripeSubscriptionID(stripeSubscriptionID) + } else { + create = create.SetStripeSubscriptionID(orgsubscription.StripeSubscriptionID) + } + + if productTier, exists := m.ProductTier(); exists { + create = create.SetProductTier(productTier) + } else { + create = create.SetProductTier(orgsubscription.ProductTier) + } + + if stripeProductTierID, exists := m.StripeProductTierID(); exists { + create = create.SetStripeProductTierID(stripeProductTierID) + } else { + create = create.SetStripeProductTierID(orgsubscription.StripeProductTierID) + } + + if stripeSubscriptionStatus, exists := m.StripeSubscriptionStatus(); exists { + create = create.SetStripeSubscriptionStatus(stripeSubscriptionStatus) + } else { + create = create.SetStripeSubscriptionStatus(orgsubscription.StripeSubscriptionStatus) + } + + if active, exists := m.Active(); exists { + create = create.SetActive(active) + } else { + create = create.SetActive(orgsubscription.Active) + } + + if stripeCustomerID, exists := m.StripeCustomerID(); exists { + create = create.SetStripeCustomerID(stripeCustomerID) + } else { + create = create.SetStripeCustomerID(orgsubscription.StripeCustomerID) + } + + if expiresAt, exists := m.ExpiresAt(); exists { + create = create.SetNillableExpiresAt(&expiresAt) + } else { + create = create.SetNillableExpiresAt(orgsubscription.ExpiresAt) + } + + if features, exists := m.Features(); exists { + create = create.SetFeatures(features) + } else { + create = create.SetFeatures(orgsubscription.Features) + } + + if _, err := create.Save(ctx); err != nil { + return err + } + } + + return nil +} + +func (m *OrgSubscriptionMutation) CreateHistoryFromDelete(ctx context.Context) error { + // check for soft delete operation and skip so it happens on update + if entx.CheckIsSoftDelete(ctx) { + return nil + } + client := m.Client() + + ids, err := m.IDs(ctx) + if err != nil { + return fmt.Errorf("getting ids: %w", err) + } + + for _, id := range ids { + orgsubscription, err := client.OrgSubscription.Get(ctx, id) + if err != nil { + return err + } + + create := client.OrgSubscriptionHistory.Create() + + _, err = create. + SetOperation(EntOpToHistoryOp(m.Op())). + SetHistoryTime(time.Now()). + SetRef(id). + SetCreatedAt(orgsubscription.CreatedAt). + SetUpdatedAt(orgsubscription.UpdatedAt). + SetCreatedBy(orgsubscription.CreatedBy). + SetUpdatedBy(orgsubscription.UpdatedBy). + SetMappingID(orgsubscription.MappingID). + SetTags(orgsubscription.Tags). + SetDeletedAt(orgsubscription.DeletedAt). + SetDeletedBy(orgsubscription.DeletedBy). + SetOwnerID(orgsubscription.OwnerID). + SetStripeSubscriptionID(orgsubscription.StripeSubscriptionID). + SetProductTier(orgsubscription.ProductTier). + SetStripeProductTierID(orgsubscription.StripeProductTierID). + SetStripeSubscriptionStatus(orgsubscription.StripeSubscriptionStatus). + SetActive(orgsubscription.Active). + SetStripeCustomerID(orgsubscription.StripeCustomerID). + SetNillableExpiresAt(orgsubscription.ExpiresAt). + SetFeatures(orgsubscription.Features). + Save(ctx) + if err != nil { + return err + } + } + + return nil +} + func (m *OrganizationMutation) CreateHistoryFromCreate(ctx context.Context) error { client := m.Client() diff --git a/internal/ent/generated/history_query.go b/internal/ent/generated/history_query.go index 0d9a69c1..30ad0d47 100644 --- a/internal/ent/generated/history_query.go +++ b/internal/ent/generated/history_query.go @@ -33,6 +33,7 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationhistory" "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/procedurehistory" "github.com/theopenlane/core/internal/ent/generated/programhistory" "github.com/theopenlane/core/internal/ent/generated/programmembershiphistory" @@ -1104,6 +1105,52 @@ func (omhq *OrgMembershipHistoryQuery) AsOf(ctx context.Context, time time.Time) First(ctx) } +func (os *OrgSubscription) History() *OrgSubscriptionHistoryQuery { + historyClient := NewOrgSubscriptionHistoryClient(os.config) + return historyClient.Query().Where(orgsubscriptionhistory.Ref(os.ID)) +} + +func (osh *OrgSubscriptionHistory) Next(ctx context.Context) (*OrgSubscriptionHistory, error) { + client := NewOrgSubscriptionHistoryClient(osh.config) + return client.Query(). + Where( + orgsubscriptionhistory.Ref(osh.Ref), + orgsubscriptionhistory.HistoryTimeGT(osh.HistoryTime), + ). + Order(orgsubscriptionhistory.ByHistoryTime()). + First(ctx) +} + +func (osh *OrgSubscriptionHistory) Prev(ctx context.Context) (*OrgSubscriptionHistory, error) { + client := NewOrgSubscriptionHistoryClient(osh.config) + return client.Query(). + Where( + orgsubscriptionhistory.Ref(osh.Ref), + orgsubscriptionhistory.HistoryTimeLT(osh.HistoryTime), + ). + Order(orgsubscriptionhistory.ByHistoryTime(sql.OrderDesc())). + First(ctx) +} + +func (oshq *OrgSubscriptionHistoryQuery) Earliest(ctx context.Context) (*OrgSubscriptionHistory, error) { + return oshq. + Order(orgsubscriptionhistory.ByHistoryTime()). + First(ctx) +} + +func (oshq *OrgSubscriptionHistoryQuery) Latest(ctx context.Context) (*OrgSubscriptionHistory, error) { + return oshq. + Order(orgsubscriptionhistory.ByHistoryTime(sql.OrderDesc())). + First(ctx) +} + +func (oshq *OrgSubscriptionHistoryQuery) AsOf(ctx context.Context, time time.Time) (*OrgSubscriptionHistory, error) { + return oshq. + Where(orgsubscriptionhistory.HistoryTimeLTE(time)). + Order(orgsubscriptionhistory.ByHistoryTime(sql.OrderDesc())). + First(ctx) +} + func (o *Organization) History() *OrganizationHistoryQuery { historyClient := NewOrganizationHistoryClient(o.config) return historyClient.Query().Where(organizationhistory.Ref(o.ID)) diff --git a/internal/ent/generated/hook/hook.go b/internal/ent/generated/hook/hook.go index b84ba385..6fa16dfd 100644 --- a/internal/ent/generated/hook/hook.go +++ b/internal/ent/generated/hook/hook.go @@ -609,6 +609,30 @@ func (f OrgMembershipHistoryFunc) Mutate(ctx context.Context, m generated.Mutati return nil, fmt.Errorf("unexpected mutation type %T. expect *generated.OrgMembershipHistoryMutation", m) } +// The OrgSubscriptionFunc type is an adapter to allow the use of ordinary +// function as OrgSubscription mutator. +type OrgSubscriptionFunc func(context.Context, *generated.OrgSubscriptionMutation) (generated.Value, error) + +// Mutate calls f(ctx, m). +func (f OrgSubscriptionFunc) Mutate(ctx context.Context, m generated.Mutation) (generated.Value, error) { + if mv, ok := m.(*generated.OrgSubscriptionMutation); ok { + return f(ctx, mv) + } + return nil, fmt.Errorf("unexpected mutation type %T. expect *generated.OrgSubscriptionMutation", m) +} + +// The OrgSubscriptionHistoryFunc type is an adapter to allow the use of ordinary +// function as OrgSubscriptionHistory mutator. +type OrgSubscriptionHistoryFunc func(context.Context, *generated.OrgSubscriptionHistoryMutation) (generated.Value, error) + +// Mutate calls f(ctx, m). +func (f OrgSubscriptionHistoryFunc) Mutate(ctx context.Context, m generated.Mutation) (generated.Value, error) { + if mv, ok := m.(*generated.OrgSubscriptionHistoryMutation); ok { + return f(ctx, mv) + } + return nil, fmt.Errorf("unexpected mutation type %T. expect *generated.OrgSubscriptionHistoryMutation", m) +} + // The OrganizationFunc type is an adapter to allow the use of ordinary // function as Organization mutator. type OrganizationFunc func(context.Context, *generated.OrganizationMutation) (generated.Value, error) diff --git a/internal/ent/generated/intercept/intercept.go b/internal/ent/generated/intercept/intercept.go index b3610f90..a0e47c0f 100644 --- a/internal/ent/generated/intercept/intercept.go +++ b/internal/ent/generated/intercept/intercept.go @@ -62,6 +62,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/passwordresettoken" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/predicate" @@ -1498,6 +1500,60 @@ func (f TraverseOrgMembershipHistory) Traverse(ctx context.Context, q generated. return fmt.Errorf("unexpected query type %T. expect *generated.OrgMembershipHistoryQuery", q) } +// The OrgSubscriptionFunc type is an adapter to allow the use of ordinary function as a Querier. +type OrgSubscriptionFunc func(context.Context, *generated.OrgSubscriptionQuery) (generated.Value, error) + +// Query calls f(ctx, q). +func (f OrgSubscriptionFunc) Query(ctx context.Context, q generated.Query) (generated.Value, error) { + if q, ok := q.(*generated.OrgSubscriptionQuery); ok { + return f(ctx, q) + } + return nil, fmt.Errorf("unexpected query type %T. expect *generated.OrgSubscriptionQuery", q) +} + +// The TraverseOrgSubscription type is an adapter to allow the use of ordinary function as Traverser. +type TraverseOrgSubscription func(context.Context, *generated.OrgSubscriptionQuery) error + +// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline. +func (f TraverseOrgSubscription) Intercept(next generated.Querier) generated.Querier { + return next +} + +// Traverse calls f(ctx, q). +func (f TraverseOrgSubscription) Traverse(ctx context.Context, q generated.Query) error { + if q, ok := q.(*generated.OrgSubscriptionQuery); ok { + return f(ctx, q) + } + return fmt.Errorf("unexpected query type %T. expect *generated.OrgSubscriptionQuery", q) +} + +// The OrgSubscriptionHistoryFunc type is an adapter to allow the use of ordinary function as a Querier. +type OrgSubscriptionHistoryFunc func(context.Context, *generated.OrgSubscriptionHistoryQuery) (generated.Value, error) + +// Query calls f(ctx, q). +func (f OrgSubscriptionHistoryFunc) Query(ctx context.Context, q generated.Query) (generated.Value, error) { + if q, ok := q.(*generated.OrgSubscriptionHistoryQuery); ok { + return f(ctx, q) + } + return nil, fmt.Errorf("unexpected query type %T. expect *generated.OrgSubscriptionHistoryQuery", q) +} + +// The TraverseOrgSubscriptionHistory type is an adapter to allow the use of ordinary function as Traverser. +type TraverseOrgSubscriptionHistory func(context.Context, *generated.OrgSubscriptionHistoryQuery) error + +// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline. +func (f TraverseOrgSubscriptionHistory) Intercept(next generated.Querier) generated.Querier { + return next +} + +// Traverse calls f(ctx, q). +func (f TraverseOrgSubscriptionHistory) Traverse(ctx context.Context, q generated.Query) error { + if q, ok := q.(*generated.OrgSubscriptionHistoryQuery); ok { + return f(ctx, q) + } + return fmt.Errorf("unexpected query type %T. expect *generated.OrgSubscriptionHistoryQuery", q) +} + // The OrganizationFunc type is an adapter to allow the use of ordinary function as a Querier. type OrganizationFunc func(context.Context, *generated.OrganizationQuery) (generated.Value, error) @@ -2438,6 +2494,10 @@ func NewQuery(q generated.Query) (Query, error) { return &query[*generated.OrgMembershipQuery, predicate.OrgMembership, orgmembership.OrderOption]{typ: generated.TypeOrgMembership, tq: q}, nil case *generated.OrgMembershipHistoryQuery: return &query[*generated.OrgMembershipHistoryQuery, predicate.OrgMembershipHistory, orgmembershiphistory.OrderOption]{typ: generated.TypeOrgMembershipHistory, tq: q}, nil + case *generated.OrgSubscriptionQuery: + return &query[*generated.OrgSubscriptionQuery, predicate.OrgSubscription, orgsubscription.OrderOption]{typ: generated.TypeOrgSubscription, tq: q}, nil + case *generated.OrgSubscriptionHistoryQuery: + return &query[*generated.OrgSubscriptionHistoryQuery, predicate.OrgSubscriptionHistory, orgsubscriptionhistory.OrderOption]{typ: generated.TypeOrgSubscriptionHistory, tq: q}, nil case *generated.OrganizationQuery: return &query[*generated.OrganizationQuery, predicate.Organization, organization.OrderOption]{typ: generated.TypeOrganization, tq: q}, nil case *generated.OrganizationHistoryQuery: diff --git a/internal/ent/generated/internal/schemaconfig.go b/internal/ent/generated/internal/schemaconfig.go index fb90b06a..bb4fda39 100644 --- a/internal/ent/generated/internal/schemaconfig.go +++ b/internal/ent/generated/internal/schemaconfig.go @@ -102,6 +102,8 @@ type SchemaConfig struct { OrgMembership string // OrgMembership table. OrgMembershipEvents string // OrgMembership-events->Event table. OrgMembershipHistory string // OrgMembershipHistory table. + OrgSubscription string // OrgSubscription table. + OrgSubscriptionHistory string // OrgSubscriptionHistory table. Organization string // Organization table. OrganizationControlCreators string // Organization-control_creators->Group table. OrganizationControlObjectiveCreators string // Organization-control_objective_creators->Group table. diff --git a/internal/ent/generated/migrate/schema.go b/internal/ent/generated/migrate/schema.go index da77acfe..82e5b03f 100644 --- a/internal/ent/generated/migrate/schema.go +++ b/internal/ent/generated/migrate/schema.go @@ -1845,6 +1845,78 @@ var ( }, }, } + // OrgSubscriptionsColumns holds the columns for the "org_subscriptions" table. + OrgSubscriptionsColumns = []*schema.Column{ + {Name: "id", Type: field.TypeString}, + {Name: "created_at", Type: field.TypeTime, Nullable: true}, + {Name: "updated_at", Type: field.TypeTime, Nullable: true}, + {Name: "created_by", Type: field.TypeString, Nullable: true}, + {Name: "updated_by", Type: field.TypeString, Nullable: true}, + {Name: "mapping_id", Type: field.TypeString, Unique: true}, + {Name: "tags", Type: field.TypeJSON, Nullable: true}, + {Name: "deleted_at", Type: field.TypeTime, Nullable: true}, + {Name: "deleted_by", Type: field.TypeString, Nullable: true}, + {Name: "stripe_subscription_id", Type: field.TypeString, Nullable: true}, + {Name: "product_tier", Type: field.TypeString, Nullable: true}, + {Name: "stripe_product_tier_id", Type: field.TypeString, Nullable: true}, + {Name: "stripe_subscription_status", Type: field.TypeString, Nullable: true}, + {Name: "active", Type: field.TypeBool, Default: true}, + {Name: "stripe_customer_id", Type: field.TypeString, Unique: true, Nullable: true}, + {Name: "expires_at", Type: field.TypeTime, Nullable: true}, + {Name: "features", Type: field.TypeJSON, Nullable: true}, + {Name: "owner_id", Type: field.TypeString, Nullable: true}, + } + // OrgSubscriptionsTable holds the schema information for the "org_subscriptions" table. + OrgSubscriptionsTable = &schema.Table{ + Name: "org_subscriptions", + Columns: OrgSubscriptionsColumns, + PrimaryKey: []*schema.Column{OrgSubscriptionsColumns[0]}, + ForeignKeys: []*schema.ForeignKey{ + { + Symbol: "org_subscriptions_organizations_orgsubscriptions", + Columns: []*schema.Column{OrgSubscriptionsColumns[17]}, + RefColumns: []*schema.Column{OrganizationsColumns[0]}, + OnDelete: schema.SetNull, + }, + }, + } + // OrgSubscriptionHistoryColumns holds the columns for the "org_subscription_history" table. + OrgSubscriptionHistoryColumns = []*schema.Column{ + {Name: "id", Type: field.TypeString}, + {Name: "history_time", Type: field.TypeTime}, + {Name: "ref", Type: field.TypeString, Nullable: true}, + {Name: "operation", Type: field.TypeEnum, Enums: []string{"INSERT", "UPDATE", "DELETE"}}, + {Name: "created_at", Type: field.TypeTime, Nullable: true}, + {Name: "updated_at", Type: field.TypeTime, Nullable: true}, + {Name: "created_by", Type: field.TypeString, Nullable: true}, + {Name: "updated_by", Type: field.TypeString, Nullable: true}, + {Name: "mapping_id", Type: field.TypeString}, + {Name: "tags", Type: field.TypeJSON, Nullable: true}, + {Name: "deleted_at", Type: field.TypeTime, Nullable: true}, + {Name: "deleted_by", Type: field.TypeString, Nullable: true}, + {Name: "owner_id", Type: field.TypeString, Nullable: true}, + {Name: "stripe_subscription_id", Type: field.TypeString, Nullable: true}, + {Name: "product_tier", Type: field.TypeString, Nullable: true}, + {Name: "stripe_product_tier_id", Type: field.TypeString, Nullable: true}, + {Name: "stripe_subscription_status", Type: field.TypeString, Nullable: true}, + {Name: "active", Type: field.TypeBool, Default: true}, + {Name: "stripe_customer_id", Type: field.TypeString, Nullable: true}, + {Name: "expires_at", Type: field.TypeTime, Nullable: true}, + {Name: "features", Type: field.TypeJSON, Nullable: true}, + } + // OrgSubscriptionHistoryTable holds the schema information for the "org_subscription_history" table. + OrgSubscriptionHistoryTable = &schema.Table{ + Name: "org_subscription_history", + Columns: OrgSubscriptionHistoryColumns, + PrimaryKey: []*schema.Column{OrgSubscriptionHistoryColumns[0]}, + Indexes: []*schema.Index{ + { + Name: "orgsubscriptionhistory_history_time", + Unique: false, + Columns: []*schema.Column{OrgSubscriptionHistoryColumns[1]}, + }, + }, + } // OrganizationsColumns holds the columns for the "organizations" table. OrganizationsColumns = []*schema.Column{ {Name: "id", Type: field.TypeString}, @@ -5570,6 +5642,8 @@ var ( OhAuthTooTokensTable, OrgMembershipsTable, OrgMembershipHistoryTable, + OrgSubscriptionsTable, + OrgSubscriptionHistoryTable, OrganizationsTable, OrganizationHistoryTable, OrganizationSettingsTable, @@ -5807,6 +5881,10 @@ func init() { OrgMembershipHistoryTable.Annotation = &entsql.Annotation{ Table: "org_membership_history", } + OrgSubscriptionsTable.ForeignKeys[0].RefTable = OrganizationsTable + OrgSubscriptionHistoryTable.Annotation = &entsql.Annotation{ + Table: "org_subscription_history", + } OrganizationsTable.ForeignKeys[0].RefTable = OrganizationsTable OrganizationHistoryTable.Annotation = &entsql.Annotation{ Table: "organization_history", diff --git a/internal/ent/generated/mutation.go b/internal/ent/generated/mutation.go index 39acca57..e885531e 100644 --- a/internal/ent/generated/mutation.go +++ b/internal/ent/generated/mutation.go @@ -66,6 +66,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/passwordresettoken" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/predicate" @@ -157,6 +159,8 @@ const ( TypeOhAuthTooToken = "OhAuthTooToken" TypeOrgMembership = "OrgMembership" TypeOrgMembershipHistory = "OrgMembershipHistory" + TypeOrgSubscription = "OrgSubscription" + TypeOrgSubscriptionHistory = "OrgSubscriptionHistory" TypeOrganization = "Organization" TypeOrganizationHistory = "OrganizationHistory" TypeOrganizationSetting = "OrganizationSetting" @@ -82239,6 +82243,3277 @@ func (m *OrgMembershipHistoryMutation) ResetEdge(name string) error { return fmt.Errorf("unknown OrgMembershipHistory edge %s", name) } +// OrgSubscriptionMutation represents an operation that mutates the OrgSubscription nodes in the graph. +type OrgSubscriptionMutation struct { + config + op Op + typ string + id *string + created_at *time.Time + updated_at *time.Time + created_by *string + updated_by *string + mapping_id *string + tags *[]string + appendtags []string + deleted_at *time.Time + deleted_by *string + stripe_subscription_id *string + product_tier *string + stripe_product_tier_id *string + stripe_subscription_status *string + active *bool + stripe_customer_id *string + expires_at *time.Time + features *[]string + appendfeatures []string + clearedFields map[string]struct{} + owner *string + clearedowner bool + done bool + oldValue func(context.Context) (*OrgSubscription, error) + predicates []predicate.OrgSubscription +} + +var _ ent.Mutation = (*OrgSubscriptionMutation)(nil) + +// orgsubscriptionOption allows management of the mutation configuration using functional options. +type orgsubscriptionOption func(*OrgSubscriptionMutation) + +// newOrgSubscriptionMutation creates new mutation for the OrgSubscription entity. +func newOrgSubscriptionMutation(c config, op Op, opts ...orgsubscriptionOption) *OrgSubscriptionMutation { + m := &OrgSubscriptionMutation{ + config: c, + op: op, + typ: TypeOrgSubscription, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withOrgSubscriptionID sets the ID field of the mutation. +func withOrgSubscriptionID(id string) orgsubscriptionOption { + return func(m *OrgSubscriptionMutation) { + var ( + err error + once sync.Once + value *OrgSubscription + ) + m.oldValue = func(ctx context.Context) (*OrgSubscription, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().OrgSubscription.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withOrgSubscription sets the old OrgSubscription of the mutation. +func withOrgSubscription(node *OrgSubscription) orgsubscriptionOption { + return func(m *OrgSubscriptionMutation) { + m.oldValue = func(context.Context) (*OrgSubscription, error) { + return node, nil + } + m.id = &node.ID + } +} + +// Client returns a new `ent.Client` from the mutation. If the mutation was +// executed in a transaction (ent.Tx), a transactional client is returned. +func (m OrgSubscriptionMutation) Client() *Client { + client := &Client{config: m.config} + client.init() + return client +} + +// Tx returns an `ent.Tx` for mutations that were executed in transactions; +// it returns an error otherwise. +func (m OrgSubscriptionMutation) Tx() (*Tx, error) { + if _, ok := m.driver.(*txDriver); !ok { + return nil, errors.New("generated: mutation is not running in a transaction") + } + tx := &Tx{config: m.config} + tx.init() + return tx, nil +} + +// SetID sets the value of the id field. Note that this +// operation is only accepted on creation of OrgSubscription entities. +func (m *OrgSubscriptionMutation) SetID(id string) { + m.id = &id +} + +// ID returns the ID value in the mutation. Note that the ID is only available +// if it was provided to the builder or after it was returned from the database. +func (m *OrgSubscriptionMutation) ID() (id string, exists bool) { + if m.id == nil { + return + } + return *m.id, true +} + +// IDs queries the database and returns the entity ids that match the mutation's predicate. +// That means, if the mutation is applied within a transaction with an isolation level such +// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated +// or updated by the mutation. +func (m *OrgSubscriptionMutation) IDs(ctx context.Context) ([]string, error) { + switch { + case m.op.Is(OpUpdateOne | OpDeleteOne): + id, exists := m.ID() + if exists { + return []string{id}, nil + } + fallthrough + case m.op.Is(OpUpdate | OpDelete): + return m.Client().OrgSubscription.Query().Where(m.predicates...).IDs(ctx) + default: + return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op) + } +} + +// SetCreatedAt sets the "created_at" field. +func (m *OrgSubscriptionMutation) SetCreatedAt(t time.Time) { + m.created_at = &t +} + +// CreatedAt returns the value of the "created_at" field in the mutation. +func (m *OrgSubscriptionMutation) CreatedAt() (r time.Time, exists bool) { + v := m.created_at + if v == nil { + return + } + return *v, true +} + +// OldCreatedAt returns the old "created_at" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCreatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err) + } + return oldValue.CreatedAt, nil +} + +// ClearCreatedAt clears the value of the "created_at" field. +func (m *OrgSubscriptionMutation) ClearCreatedAt() { + m.created_at = nil + m.clearedFields[orgsubscription.FieldCreatedAt] = struct{}{} +} + +// CreatedAtCleared returns if the "created_at" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) CreatedAtCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldCreatedAt] + return ok +} + +// ResetCreatedAt resets all changes to the "created_at" field. +func (m *OrgSubscriptionMutation) ResetCreatedAt() { + m.created_at = nil + delete(m.clearedFields, orgsubscription.FieldCreatedAt) +} + +// SetUpdatedAt sets the "updated_at" field. +func (m *OrgSubscriptionMutation) SetUpdatedAt(t time.Time) { + m.updated_at = &t +} + +// UpdatedAt returns the value of the "updated_at" field in the mutation. +func (m *OrgSubscriptionMutation) UpdatedAt() (r time.Time, exists bool) { + v := m.updated_at + if v == nil { + return + } + return *v, true +} + +// OldUpdatedAt returns the old "updated_at" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUpdatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err) + } + return oldValue.UpdatedAt, nil +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (m *OrgSubscriptionMutation) ClearUpdatedAt() { + m.updated_at = nil + m.clearedFields[orgsubscription.FieldUpdatedAt] = struct{}{} +} + +// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) UpdatedAtCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldUpdatedAt] + return ok +} + +// ResetUpdatedAt resets all changes to the "updated_at" field. +func (m *OrgSubscriptionMutation) ResetUpdatedAt() { + m.updated_at = nil + delete(m.clearedFields, orgsubscription.FieldUpdatedAt) +} + +// SetCreatedBy sets the "created_by" field. +func (m *OrgSubscriptionMutation) SetCreatedBy(s string) { + m.created_by = &s +} + +// CreatedBy returns the value of the "created_by" field in the mutation. +func (m *OrgSubscriptionMutation) CreatedBy() (r string, exists bool) { + v := m.created_by + if v == nil { + return + } + return *v, true +} + +// OldCreatedBy returns the old "created_by" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldCreatedBy(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCreatedBy is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCreatedBy requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCreatedBy: %w", err) + } + return oldValue.CreatedBy, nil +} + +// ClearCreatedBy clears the value of the "created_by" field. +func (m *OrgSubscriptionMutation) ClearCreatedBy() { + m.created_by = nil + m.clearedFields[orgsubscription.FieldCreatedBy] = struct{}{} +} + +// CreatedByCleared returns if the "created_by" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) CreatedByCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldCreatedBy] + return ok +} + +// ResetCreatedBy resets all changes to the "created_by" field. +func (m *OrgSubscriptionMutation) ResetCreatedBy() { + m.created_by = nil + delete(m.clearedFields, orgsubscription.FieldCreatedBy) +} + +// SetUpdatedBy sets the "updated_by" field. +func (m *OrgSubscriptionMutation) SetUpdatedBy(s string) { + m.updated_by = &s +} + +// UpdatedBy returns the value of the "updated_by" field in the mutation. +func (m *OrgSubscriptionMutation) UpdatedBy() (r string, exists bool) { + v := m.updated_by + if v == nil { + return + } + return *v, true +} + +// OldUpdatedBy returns the old "updated_by" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldUpdatedBy(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUpdatedBy is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUpdatedBy requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUpdatedBy: %w", err) + } + return oldValue.UpdatedBy, nil +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (m *OrgSubscriptionMutation) ClearUpdatedBy() { + m.updated_by = nil + m.clearedFields[orgsubscription.FieldUpdatedBy] = struct{}{} +} + +// UpdatedByCleared returns if the "updated_by" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) UpdatedByCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldUpdatedBy] + return ok +} + +// ResetUpdatedBy resets all changes to the "updated_by" field. +func (m *OrgSubscriptionMutation) ResetUpdatedBy() { + m.updated_by = nil + delete(m.clearedFields, orgsubscription.FieldUpdatedBy) +} + +// SetMappingID sets the "mapping_id" field. +func (m *OrgSubscriptionMutation) SetMappingID(s string) { + m.mapping_id = &s +} + +// MappingID returns the value of the "mapping_id" field in the mutation. +func (m *OrgSubscriptionMutation) MappingID() (r string, exists bool) { + v := m.mapping_id + if v == nil { + return + } + return *v, true +} + +// OldMappingID returns the old "mapping_id" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldMappingID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldMappingID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldMappingID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldMappingID: %w", err) + } + return oldValue.MappingID, nil +} + +// ResetMappingID resets all changes to the "mapping_id" field. +func (m *OrgSubscriptionMutation) ResetMappingID() { + m.mapping_id = nil +} + +// SetTags sets the "tags" field. +func (m *OrgSubscriptionMutation) SetTags(s []string) { + m.tags = &s + m.appendtags = nil +} + +// Tags returns the value of the "tags" field in the mutation. +func (m *OrgSubscriptionMutation) Tags() (r []string, exists bool) { + v := m.tags + if v == nil { + return + } + return *v, true +} + +// OldTags returns the old "tags" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldTags(ctx context.Context) (v []string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTags is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTags requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTags: %w", err) + } + return oldValue.Tags, nil +} + +// AppendTags adds s to the "tags" field. +func (m *OrgSubscriptionMutation) AppendTags(s []string) { + m.appendtags = append(m.appendtags, s...) +} + +// AppendedTags returns the list of values that were appended to the "tags" field in this mutation. +func (m *OrgSubscriptionMutation) AppendedTags() ([]string, bool) { + if len(m.appendtags) == 0 { + return nil, false + } + return m.appendtags, true +} + +// ClearTags clears the value of the "tags" field. +func (m *OrgSubscriptionMutation) ClearTags() { + m.tags = nil + m.appendtags = nil + m.clearedFields[orgsubscription.FieldTags] = struct{}{} +} + +// TagsCleared returns if the "tags" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) TagsCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldTags] + return ok +} + +// ResetTags resets all changes to the "tags" field. +func (m *OrgSubscriptionMutation) ResetTags() { + m.tags = nil + m.appendtags = nil + delete(m.clearedFields, orgsubscription.FieldTags) +} + +// SetDeletedAt sets the "deleted_at" field. +func (m *OrgSubscriptionMutation) SetDeletedAt(t time.Time) { + m.deleted_at = &t +} + +// DeletedAt returns the value of the "deleted_at" field in the mutation. +func (m *OrgSubscriptionMutation) DeletedAt() (r time.Time, exists bool) { + v := m.deleted_at + if v == nil { + return + } + return *v, true +} + +// OldDeletedAt returns the old "deleted_at" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldDeletedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err) + } + return oldValue.DeletedAt, nil +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (m *OrgSubscriptionMutation) ClearDeletedAt() { + m.deleted_at = nil + m.clearedFields[orgsubscription.FieldDeletedAt] = struct{}{} +} + +// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) DeletedAtCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldDeletedAt] + return ok +} + +// ResetDeletedAt resets all changes to the "deleted_at" field. +func (m *OrgSubscriptionMutation) ResetDeletedAt() { + m.deleted_at = nil + delete(m.clearedFields, orgsubscription.FieldDeletedAt) +} + +// SetDeletedBy sets the "deleted_by" field. +func (m *OrgSubscriptionMutation) SetDeletedBy(s string) { + m.deleted_by = &s +} + +// DeletedBy returns the value of the "deleted_by" field in the mutation. +func (m *OrgSubscriptionMutation) DeletedBy() (r string, exists bool) { + v := m.deleted_by + if v == nil { + return + } + return *v, true +} + +// OldDeletedBy returns the old "deleted_by" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldDeletedBy(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldDeletedBy is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldDeletedBy requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldDeletedBy: %w", err) + } + return oldValue.DeletedBy, nil +} + +// ClearDeletedBy clears the value of the "deleted_by" field. +func (m *OrgSubscriptionMutation) ClearDeletedBy() { + m.deleted_by = nil + m.clearedFields[orgsubscription.FieldDeletedBy] = struct{}{} +} + +// DeletedByCleared returns if the "deleted_by" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) DeletedByCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldDeletedBy] + return ok +} + +// ResetDeletedBy resets all changes to the "deleted_by" field. +func (m *OrgSubscriptionMutation) ResetDeletedBy() { + m.deleted_by = nil + delete(m.clearedFields, orgsubscription.FieldDeletedBy) +} + +// SetOwnerID sets the "owner_id" field. +func (m *OrgSubscriptionMutation) SetOwnerID(s string) { + m.owner = &s +} + +// OwnerID returns the value of the "owner_id" field in the mutation. +func (m *OrgSubscriptionMutation) OwnerID() (r string, exists bool) { + v := m.owner + if v == nil { + return + } + return *v, true +} + +// OldOwnerID returns the old "owner_id" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldOwnerID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldOwnerID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldOwnerID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldOwnerID: %w", err) + } + return oldValue.OwnerID, nil +} + +// ClearOwnerID clears the value of the "owner_id" field. +func (m *OrgSubscriptionMutation) ClearOwnerID() { + m.owner = nil + m.clearedFields[orgsubscription.FieldOwnerID] = struct{}{} +} + +// OwnerIDCleared returns if the "owner_id" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) OwnerIDCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldOwnerID] + return ok +} + +// ResetOwnerID resets all changes to the "owner_id" field. +func (m *OrgSubscriptionMutation) ResetOwnerID() { + m.owner = nil + delete(m.clearedFields, orgsubscription.FieldOwnerID) +} + +// SetStripeSubscriptionID sets the "stripe_subscription_id" field. +func (m *OrgSubscriptionMutation) SetStripeSubscriptionID(s string) { + m.stripe_subscription_id = &s +} + +// StripeSubscriptionID returns the value of the "stripe_subscription_id" field in the mutation. +func (m *OrgSubscriptionMutation) StripeSubscriptionID() (r string, exists bool) { + v := m.stripe_subscription_id + if v == nil { + return + } + return *v, true +} + +// OldStripeSubscriptionID returns the old "stripe_subscription_id" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldStripeSubscriptionID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStripeSubscriptionID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStripeSubscriptionID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStripeSubscriptionID: %w", err) + } + return oldValue.StripeSubscriptionID, nil +} + +// ClearStripeSubscriptionID clears the value of the "stripe_subscription_id" field. +func (m *OrgSubscriptionMutation) ClearStripeSubscriptionID() { + m.stripe_subscription_id = nil + m.clearedFields[orgsubscription.FieldStripeSubscriptionID] = struct{}{} +} + +// StripeSubscriptionIDCleared returns if the "stripe_subscription_id" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) StripeSubscriptionIDCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldStripeSubscriptionID] + return ok +} + +// ResetStripeSubscriptionID resets all changes to the "stripe_subscription_id" field. +func (m *OrgSubscriptionMutation) ResetStripeSubscriptionID() { + m.stripe_subscription_id = nil + delete(m.clearedFields, orgsubscription.FieldStripeSubscriptionID) +} + +// SetProductTier sets the "product_tier" field. +func (m *OrgSubscriptionMutation) SetProductTier(s string) { + m.product_tier = &s +} + +// ProductTier returns the value of the "product_tier" field in the mutation. +func (m *OrgSubscriptionMutation) ProductTier() (r string, exists bool) { + v := m.product_tier + if v == nil { + return + } + return *v, true +} + +// OldProductTier returns the old "product_tier" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldProductTier(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldProductTier is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldProductTier requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldProductTier: %w", err) + } + return oldValue.ProductTier, nil +} + +// ClearProductTier clears the value of the "product_tier" field. +func (m *OrgSubscriptionMutation) ClearProductTier() { + m.product_tier = nil + m.clearedFields[orgsubscription.FieldProductTier] = struct{}{} +} + +// ProductTierCleared returns if the "product_tier" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) ProductTierCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldProductTier] + return ok +} + +// ResetProductTier resets all changes to the "product_tier" field. +func (m *OrgSubscriptionMutation) ResetProductTier() { + m.product_tier = nil + delete(m.clearedFields, orgsubscription.FieldProductTier) +} + +// SetStripeProductTierID sets the "stripe_product_tier_id" field. +func (m *OrgSubscriptionMutation) SetStripeProductTierID(s string) { + m.stripe_product_tier_id = &s +} + +// StripeProductTierID returns the value of the "stripe_product_tier_id" field in the mutation. +func (m *OrgSubscriptionMutation) StripeProductTierID() (r string, exists bool) { + v := m.stripe_product_tier_id + if v == nil { + return + } + return *v, true +} + +// OldStripeProductTierID returns the old "stripe_product_tier_id" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldStripeProductTierID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStripeProductTierID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStripeProductTierID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStripeProductTierID: %w", err) + } + return oldValue.StripeProductTierID, nil +} + +// ClearStripeProductTierID clears the value of the "stripe_product_tier_id" field. +func (m *OrgSubscriptionMutation) ClearStripeProductTierID() { + m.stripe_product_tier_id = nil + m.clearedFields[orgsubscription.FieldStripeProductTierID] = struct{}{} +} + +// StripeProductTierIDCleared returns if the "stripe_product_tier_id" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) StripeProductTierIDCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldStripeProductTierID] + return ok +} + +// ResetStripeProductTierID resets all changes to the "stripe_product_tier_id" field. +func (m *OrgSubscriptionMutation) ResetStripeProductTierID() { + m.stripe_product_tier_id = nil + delete(m.clearedFields, orgsubscription.FieldStripeProductTierID) +} + +// SetStripeSubscriptionStatus sets the "stripe_subscription_status" field. +func (m *OrgSubscriptionMutation) SetStripeSubscriptionStatus(s string) { + m.stripe_subscription_status = &s +} + +// StripeSubscriptionStatus returns the value of the "stripe_subscription_status" field in the mutation. +func (m *OrgSubscriptionMutation) StripeSubscriptionStatus() (r string, exists bool) { + v := m.stripe_subscription_status + if v == nil { + return + } + return *v, true +} + +// OldStripeSubscriptionStatus returns the old "stripe_subscription_status" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldStripeSubscriptionStatus(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStripeSubscriptionStatus is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStripeSubscriptionStatus requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStripeSubscriptionStatus: %w", err) + } + return oldValue.StripeSubscriptionStatus, nil +} + +// ClearStripeSubscriptionStatus clears the value of the "stripe_subscription_status" field. +func (m *OrgSubscriptionMutation) ClearStripeSubscriptionStatus() { + m.stripe_subscription_status = nil + m.clearedFields[orgsubscription.FieldStripeSubscriptionStatus] = struct{}{} +} + +// StripeSubscriptionStatusCleared returns if the "stripe_subscription_status" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) StripeSubscriptionStatusCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldStripeSubscriptionStatus] + return ok +} + +// ResetStripeSubscriptionStatus resets all changes to the "stripe_subscription_status" field. +func (m *OrgSubscriptionMutation) ResetStripeSubscriptionStatus() { + m.stripe_subscription_status = nil + delete(m.clearedFields, orgsubscription.FieldStripeSubscriptionStatus) +} + +// SetActive sets the "active" field. +func (m *OrgSubscriptionMutation) SetActive(b bool) { + m.active = &b +} + +// Active returns the value of the "active" field in the mutation. +func (m *OrgSubscriptionMutation) Active() (r bool, exists bool) { + v := m.active + if v == nil { + return + } + return *v, true +} + +// OldActive returns the old "active" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldActive(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldActive is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldActive requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldActive: %w", err) + } + return oldValue.Active, nil +} + +// ResetActive resets all changes to the "active" field. +func (m *OrgSubscriptionMutation) ResetActive() { + m.active = nil +} + +// SetStripeCustomerID sets the "stripe_customer_id" field. +func (m *OrgSubscriptionMutation) SetStripeCustomerID(s string) { + m.stripe_customer_id = &s +} + +// StripeCustomerID returns the value of the "stripe_customer_id" field in the mutation. +func (m *OrgSubscriptionMutation) StripeCustomerID() (r string, exists bool) { + v := m.stripe_customer_id + if v == nil { + return + } + return *v, true +} + +// OldStripeCustomerID returns the old "stripe_customer_id" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldStripeCustomerID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStripeCustomerID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStripeCustomerID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStripeCustomerID: %w", err) + } + return oldValue.StripeCustomerID, nil +} + +// ClearStripeCustomerID clears the value of the "stripe_customer_id" field. +func (m *OrgSubscriptionMutation) ClearStripeCustomerID() { + m.stripe_customer_id = nil + m.clearedFields[orgsubscription.FieldStripeCustomerID] = struct{}{} +} + +// StripeCustomerIDCleared returns if the "stripe_customer_id" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) StripeCustomerIDCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldStripeCustomerID] + return ok +} + +// ResetStripeCustomerID resets all changes to the "stripe_customer_id" field. +func (m *OrgSubscriptionMutation) ResetStripeCustomerID() { + m.stripe_customer_id = nil + delete(m.clearedFields, orgsubscription.FieldStripeCustomerID) +} + +// SetExpiresAt sets the "expires_at" field. +func (m *OrgSubscriptionMutation) SetExpiresAt(t time.Time) { + m.expires_at = &t +} + +// ExpiresAt returns the value of the "expires_at" field in the mutation. +func (m *OrgSubscriptionMutation) ExpiresAt() (r time.Time, exists bool) { + v := m.expires_at + if v == nil { + return + } + return *v, true +} + +// OldExpiresAt returns the old "expires_at" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldExpiresAt(ctx context.Context) (v *time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldExpiresAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldExpiresAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldExpiresAt: %w", err) + } + return oldValue.ExpiresAt, nil +} + +// ClearExpiresAt clears the value of the "expires_at" field. +func (m *OrgSubscriptionMutation) ClearExpiresAt() { + m.expires_at = nil + m.clearedFields[orgsubscription.FieldExpiresAt] = struct{}{} +} + +// ExpiresAtCleared returns if the "expires_at" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) ExpiresAtCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldExpiresAt] + return ok +} + +// ResetExpiresAt resets all changes to the "expires_at" field. +func (m *OrgSubscriptionMutation) ResetExpiresAt() { + m.expires_at = nil + delete(m.clearedFields, orgsubscription.FieldExpiresAt) +} + +// SetFeatures sets the "features" field. +func (m *OrgSubscriptionMutation) SetFeatures(s []string) { + m.features = &s + m.appendfeatures = nil +} + +// Features returns the value of the "features" field in the mutation. +func (m *OrgSubscriptionMutation) Features() (r []string, exists bool) { + v := m.features + if v == nil { + return + } + return *v, true +} + +// OldFeatures returns the old "features" field's value of the OrgSubscription entity. +// If the OrgSubscription object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionMutation) OldFeatures(ctx context.Context) (v []string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldFeatures is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldFeatures requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldFeatures: %w", err) + } + return oldValue.Features, nil +} + +// AppendFeatures adds s to the "features" field. +func (m *OrgSubscriptionMutation) AppendFeatures(s []string) { + m.appendfeatures = append(m.appendfeatures, s...) +} + +// AppendedFeatures returns the list of values that were appended to the "features" field in this mutation. +func (m *OrgSubscriptionMutation) AppendedFeatures() ([]string, bool) { + if len(m.appendfeatures) == 0 { + return nil, false + } + return m.appendfeatures, true +} + +// ClearFeatures clears the value of the "features" field. +func (m *OrgSubscriptionMutation) ClearFeatures() { + m.features = nil + m.appendfeatures = nil + m.clearedFields[orgsubscription.FieldFeatures] = struct{}{} +} + +// FeaturesCleared returns if the "features" field was cleared in this mutation. +func (m *OrgSubscriptionMutation) FeaturesCleared() bool { + _, ok := m.clearedFields[orgsubscription.FieldFeatures] + return ok +} + +// ResetFeatures resets all changes to the "features" field. +func (m *OrgSubscriptionMutation) ResetFeatures() { + m.features = nil + m.appendfeatures = nil + delete(m.clearedFields, orgsubscription.FieldFeatures) +} + +// ClearOwner clears the "owner" edge to the Organization entity. +func (m *OrgSubscriptionMutation) ClearOwner() { + m.clearedowner = true + m.clearedFields[orgsubscription.FieldOwnerID] = struct{}{} +} + +// OwnerCleared reports if the "owner" edge to the Organization entity was cleared. +func (m *OrgSubscriptionMutation) OwnerCleared() bool { + return m.OwnerIDCleared() || m.clearedowner +} + +// OwnerIDs returns the "owner" edge IDs in the mutation. +// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use +// OwnerID instead. It exists only for internal usage by the builders. +func (m *OrgSubscriptionMutation) OwnerIDs() (ids []string) { + if id := m.owner; id != nil { + ids = append(ids, *id) + } + return +} + +// ResetOwner resets all changes to the "owner" edge. +func (m *OrgSubscriptionMutation) ResetOwner() { + m.owner = nil + m.clearedowner = false +} + +// Where appends a list predicates to the OrgSubscriptionMutation builder. +func (m *OrgSubscriptionMutation) Where(ps ...predicate.OrgSubscription) { + m.predicates = append(m.predicates, ps...) +} + +// WhereP appends storage-level predicates to the OrgSubscriptionMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *OrgSubscriptionMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.OrgSubscription, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + +// Op returns the operation name. +func (m *OrgSubscriptionMutation) Op() Op { + return m.op +} + +// SetOp allows setting the mutation operation. +func (m *OrgSubscriptionMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (OrgSubscription). +func (m *OrgSubscriptionMutation) Type() string { + return m.typ +} + +// Fields returns all fields that were changed during this mutation. Note that in +// order to get all numeric fields that were incremented/decremented, call +// AddedFields(). +func (m *OrgSubscriptionMutation) Fields() []string { + fields := make([]string, 0, 17) + if m.created_at != nil { + fields = append(fields, orgsubscription.FieldCreatedAt) + } + if m.updated_at != nil { + fields = append(fields, orgsubscription.FieldUpdatedAt) + } + if m.created_by != nil { + fields = append(fields, orgsubscription.FieldCreatedBy) + } + if m.updated_by != nil { + fields = append(fields, orgsubscription.FieldUpdatedBy) + } + if m.mapping_id != nil { + fields = append(fields, orgsubscription.FieldMappingID) + } + if m.tags != nil { + fields = append(fields, orgsubscription.FieldTags) + } + if m.deleted_at != nil { + fields = append(fields, orgsubscription.FieldDeletedAt) + } + if m.deleted_by != nil { + fields = append(fields, orgsubscription.FieldDeletedBy) + } + if m.owner != nil { + fields = append(fields, orgsubscription.FieldOwnerID) + } + if m.stripe_subscription_id != nil { + fields = append(fields, orgsubscription.FieldStripeSubscriptionID) + } + if m.product_tier != nil { + fields = append(fields, orgsubscription.FieldProductTier) + } + if m.stripe_product_tier_id != nil { + fields = append(fields, orgsubscription.FieldStripeProductTierID) + } + if m.stripe_subscription_status != nil { + fields = append(fields, orgsubscription.FieldStripeSubscriptionStatus) + } + if m.active != nil { + fields = append(fields, orgsubscription.FieldActive) + } + if m.stripe_customer_id != nil { + fields = append(fields, orgsubscription.FieldStripeCustomerID) + } + if m.expires_at != nil { + fields = append(fields, orgsubscription.FieldExpiresAt) + } + if m.features != nil { + fields = append(fields, orgsubscription.FieldFeatures) + } + return fields +} + +// Field returns the value of a field with the given name. The second boolean +// return value indicates that this field was not set, or was not defined in the +// schema. +func (m *OrgSubscriptionMutation) Field(name string) (ent.Value, bool) { + switch name { + case orgsubscription.FieldCreatedAt: + return m.CreatedAt() + case orgsubscription.FieldUpdatedAt: + return m.UpdatedAt() + case orgsubscription.FieldCreatedBy: + return m.CreatedBy() + case orgsubscription.FieldUpdatedBy: + return m.UpdatedBy() + case orgsubscription.FieldMappingID: + return m.MappingID() + case orgsubscription.FieldTags: + return m.Tags() + case orgsubscription.FieldDeletedAt: + return m.DeletedAt() + case orgsubscription.FieldDeletedBy: + return m.DeletedBy() + case orgsubscription.FieldOwnerID: + return m.OwnerID() + case orgsubscription.FieldStripeSubscriptionID: + return m.StripeSubscriptionID() + case orgsubscription.FieldProductTier: + return m.ProductTier() + case orgsubscription.FieldStripeProductTierID: + return m.StripeProductTierID() + case orgsubscription.FieldStripeSubscriptionStatus: + return m.StripeSubscriptionStatus() + case orgsubscription.FieldActive: + return m.Active() + case orgsubscription.FieldStripeCustomerID: + return m.StripeCustomerID() + case orgsubscription.FieldExpiresAt: + return m.ExpiresAt() + case orgsubscription.FieldFeatures: + return m.Features() + } + return nil, false +} + +// OldField returns the old value of the field from the database. An error is +// returned if the mutation operation is not UpdateOne, or the query to the +// database failed. +func (m *OrgSubscriptionMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case orgsubscription.FieldCreatedAt: + return m.OldCreatedAt(ctx) + case orgsubscription.FieldUpdatedAt: + return m.OldUpdatedAt(ctx) + case orgsubscription.FieldCreatedBy: + return m.OldCreatedBy(ctx) + case orgsubscription.FieldUpdatedBy: + return m.OldUpdatedBy(ctx) + case orgsubscription.FieldMappingID: + return m.OldMappingID(ctx) + case orgsubscription.FieldTags: + return m.OldTags(ctx) + case orgsubscription.FieldDeletedAt: + return m.OldDeletedAt(ctx) + case orgsubscription.FieldDeletedBy: + return m.OldDeletedBy(ctx) + case orgsubscription.FieldOwnerID: + return m.OldOwnerID(ctx) + case orgsubscription.FieldStripeSubscriptionID: + return m.OldStripeSubscriptionID(ctx) + case orgsubscription.FieldProductTier: + return m.OldProductTier(ctx) + case orgsubscription.FieldStripeProductTierID: + return m.OldStripeProductTierID(ctx) + case orgsubscription.FieldStripeSubscriptionStatus: + return m.OldStripeSubscriptionStatus(ctx) + case orgsubscription.FieldActive: + return m.OldActive(ctx) + case orgsubscription.FieldStripeCustomerID: + return m.OldStripeCustomerID(ctx) + case orgsubscription.FieldExpiresAt: + return m.OldExpiresAt(ctx) + case orgsubscription.FieldFeatures: + return m.OldFeatures(ctx) + } + return nil, fmt.Errorf("unknown OrgSubscription field %s", name) +} + +// SetField sets the value of a field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *OrgSubscriptionMutation) SetField(name string, value ent.Value) error { + switch name { + case orgsubscription.FieldCreatedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCreatedAt(v) + return nil + case orgsubscription.FieldUpdatedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUpdatedAt(v) + return nil + case orgsubscription.FieldCreatedBy: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCreatedBy(v) + return nil + case orgsubscription.FieldUpdatedBy: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUpdatedBy(v) + return nil + case orgsubscription.FieldMappingID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetMappingID(v) + return nil + case orgsubscription.FieldTags: + v, ok := value.([]string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTags(v) + return nil + case orgsubscription.FieldDeletedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetDeletedAt(v) + return nil + case orgsubscription.FieldDeletedBy: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetDeletedBy(v) + return nil + case orgsubscription.FieldOwnerID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetOwnerID(v) + return nil + case orgsubscription.FieldStripeSubscriptionID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStripeSubscriptionID(v) + return nil + case orgsubscription.FieldProductTier: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetProductTier(v) + return nil + case orgsubscription.FieldStripeProductTierID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStripeProductTierID(v) + return nil + case orgsubscription.FieldStripeSubscriptionStatus: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStripeSubscriptionStatus(v) + return nil + case orgsubscription.FieldActive: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetActive(v) + return nil + case orgsubscription.FieldStripeCustomerID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStripeCustomerID(v) + return nil + case orgsubscription.FieldExpiresAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetExpiresAt(v) + return nil + case orgsubscription.FieldFeatures: + v, ok := value.([]string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetFeatures(v) + return nil + } + return fmt.Errorf("unknown OrgSubscription field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *OrgSubscriptionMutation) AddedFields() []string { + return nil +} + +// AddedField returns the numeric value that was incremented/decremented on a field +// with the given name. The second boolean return value indicates that this field +// was not set, or was not defined in the schema. +func (m *OrgSubscriptionMutation) AddedField(name string) (ent.Value, bool) { + return nil, false +} + +// AddField adds the value to the field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *OrgSubscriptionMutation) AddField(name string, value ent.Value) error { + switch name { + } + return fmt.Errorf("unknown OrgSubscription numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *OrgSubscriptionMutation) ClearedFields() []string { + var fields []string + if m.FieldCleared(orgsubscription.FieldCreatedAt) { + fields = append(fields, orgsubscription.FieldCreatedAt) + } + if m.FieldCleared(orgsubscription.FieldUpdatedAt) { + fields = append(fields, orgsubscription.FieldUpdatedAt) + } + if m.FieldCleared(orgsubscription.FieldCreatedBy) { + fields = append(fields, orgsubscription.FieldCreatedBy) + } + if m.FieldCleared(orgsubscription.FieldUpdatedBy) { + fields = append(fields, orgsubscription.FieldUpdatedBy) + } + if m.FieldCleared(orgsubscription.FieldTags) { + fields = append(fields, orgsubscription.FieldTags) + } + if m.FieldCleared(orgsubscription.FieldDeletedAt) { + fields = append(fields, orgsubscription.FieldDeletedAt) + } + if m.FieldCleared(orgsubscription.FieldDeletedBy) { + fields = append(fields, orgsubscription.FieldDeletedBy) + } + if m.FieldCleared(orgsubscription.FieldOwnerID) { + fields = append(fields, orgsubscription.FieldOwnerID) + } + if m.FieldCleared(orgsubscription.FieldStripeSubscriptionID) { + fields = append(fields, orgsubscription.FieldStripeSubscriptionID) + } + if m.FieldCleared(orgsubscription.FieldProductTier) { + fields = append(fields, orgsubscription.FieldProductTier) + } + if m.FieldCleared(orgsubscription.FieldStripeProductTierID) { + fields = append(fields, orgsubscription.FieldStripeProductTierID) + } + if m.FieldCleared(orgsubscription.FieldStripeSubscriptionStatus) { + fields = append(fields, orgsubscription.FieldStripeSubscriptionStatus) + } + if m.FieldCleared(orgsubscription.FieldStripeCustomerID) { + fields = append(fields, orgsubscription.FieldStripeCustomerID) + } + if m.FieldCleared(orgsubscription.FieldExpiresAt) { + fields = append(fields, orgsubscription.FieldExpiresAt) + } + if m.FieldCleared(orgsubscription.FieldFeatures) { + fields = append(fields, orgsubscription.FieldFeatures) + } + return fields +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *OrgSubscriptionMutation) FieldCleared(name string) bool { + _, ok := m.clearedFields[name] + return ok +} + +// ClearField clears the value of the field with the given name. It returns an +// error if the field is not defined in the schema. +func (m *OrgSubscriptionMutation) ClearField(name string) error { + switch name { + case orgsubscription.FieldCreatedAt: + m.ClearCreatedAt() + return nil + case orgsubscription.FieldUpdatedAt: + m.ClearUpdatedAt() + return nil + case orgsubscription.FieldCreatedBy: + m.ClearCreatedBy() + return nil + case orgsubscription.FieldUpdatedBy: + m.ClearUpdatedBy() + return nil + case orgsubscription.FieldTags: + m.ClearTags() + return nil + case orgsubscription.FieldDeletedAt: + m.ClearDeletedAt() + return nil + case orgsubscription.FieldDeletedBy: + m.ClearDeletedBy() + return nil + case orgsubscription.FieldOwnerID: + m.ClearOwnerID() + return nil + case orgsubscription.FieldStripeSubscriptionID: + m.ClearStripeSubscriptionID() + return nil + case orgsubscription.FieldProductTier: + m.ClearProductTier() + return nil + case orgsubscription.FieldStripeProductTierID: + m.ClearStripeProductTierID() + return nil + case orgsubscription.FieldStripeSubscriptionStatus: + m.ClearStripeSubscriptionStatus() + return nil + case orgsubscription.FieldStripeCustomerID: + m.ClearStripeCustomerID() + return nil + case orgsubscription.FieldExpiresAt: + m.ClearExpiresAt() + return nil + case orgsubscription.FieldFeatures: + m.ClearFeatures() + return nil + } + return fmt.Errorf("unknown OrgSubscription nullable field %s", name) +} + +// ResetField resets all changes in the mutation for the field with the given name. +// It returns an error if the field is not defined in the schema. +func (m *OrgSubscriptionMutation) ResetField(name string) error { + switch name { + case orgsubscription.FieldCreatedAt: + m.ResetCreatedAt() + return nil + case orgsubscription.FieldUpdatedAt: + m.ResetUpdatedAt() + return nil + case orgsubscription.FieldCreatedBy: + m.ResetCreatedBy() + return nil + case orgsubscription.FieldUpdatedBy: + m.ResetUpdatedBy() + return nil + case orgsubscription.FieldMappingID: + m.ResetMappingID() + return nil + case orgsubscription.FieldTags: + m.ResetTags() + return nil + case orgsubscription.FieldDeletedAt: + m.ResetDeletedAt() + return nil + case orgsubscription.FieldDeletedBy: + m.ResetDeletedBy() + return nil + case orgsubscription.FieldOwnerID: + m.ResetOwnerID() + return nil + case orgsubscription.FieldStripeSubscriptionID: + m.ResetStripeSubscriptionID() + return nil + case orgsubscription.FieldProductTier: + m.ResetProductTier() + return nil + case orgsubscription.FieldStripeProductTierID: + m.ResetStripeProductTierID() + return nil + case orgsubscription.FieldStripeSubscriptionStatus: + m.ResetStripeSubscriptionStatus() + return nil + case orgsubscription.FieldActive: + m.ResetActive() + return nil + case orgsubscription.FieldStripeCustomerID: + m.ResetStripeCustomerID() + return nil + case orgsubscription.FieldExpiresAt: + m.ResetExpiresAt() + return nil + case orgsubscription.FieldFeatures: + m.ResetFeatures() + return nil + } + return fmt.Errorf("unknown OrgSubscription field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *OrgSubscriptionMutation) AddedEdges() []string { + edges := make([]string, 0, 1) + if m.owner != nil { + edges = append(edges, orgsubscription.EdgeOwner) + } + return edges +} + +// AddedIDs returns all IDs (to other nodes) that were added for the given edge +// name in this mutation. +func (m *OrgSubscriptionMutation) AddedIDs(name string) []ent.Value { + switch name { + case orgsubscription.EdgeOwner: + if id := m.owner; id != nil { + return []ent.Value{*id} + } + } + return nil +} + +// RemovedEdges returns all edge names that were removed in this mutation. +func (m *OrgSubscriptionMutation) RemovedEdges() []string { + edges := make([]string, 0, 1) + return edges +} + +// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with +// the given name in this mutation. +func (m *OrgSubscriptionMutation) RemovedIDs(name string) []ent.Value { + return nil +} + +// ClearedEdges returns all edge names that were cleared in this mutation. +func (m *OrgSubscriptionMutation) ClearedEdges() []string { + edges := make([]string, 0, 1) + if m.clearedowner { + edges = append(edges, orgsubscription.EdgeOwner) + } + return edges +} + +// EdgeCleared returns a boolean which indicates if the edge with the given name +// was cleared in this mutation. +func (m *OrgSubscriptionMutation) EdgeCleared(name string) bool { + switch name { + case orgsubscription.EdgeOwner: + return m.clearedowner + } + return false +} + +// ClearEdge clears the value of the edge with the given name. It returns an error +// if that edge is not defined in the schema. +func (m *OrgSubscriptionMutation) ClearEdge(name string) error { + switch name { + case orgsubscription.EdgeOwner: + m.ClearOwner() + return nil + } + return fmt.Errorf("unknown OrgSubscription unique edge %s", name) +} + +// ResetEdge resets all changes to the edge with the given name in this mutation. +// It returns an error if the edge is not defined in the schema. +func (m *OrgSubscriptionMutation) ResetEdge(name string) error { + switch name { + case orgsubscription.EdgeOwner: + m.ResetOwner() + return nil + } + return fmt.Errorf("unknown OrgSubscription edge %s", name) +} + +// OrgSubscriptionHistoryMutation represents an operation that mutates the OrgSubscriptionHistory nodes in the graph. +type OrgSubscriptionHistoryMutation struct { + config + op Op + typ string + id *string + history_time *time.Time + ref *string + operation *history.OpType + created_at *time.Time + updated_at *time.Time + created_by *string + updated_by *string + mapping_id *string + tags *[]string + appendtags []string + deleted_at *time.Time + deleted_by *string + owner_id *string + stripe_subscription_id *string + product_tier *string + stripe_product_tier_id *string + stripe_subscription_status *string + active *bool + stripe_customer_id *string + expires_at *time.Time + features *[]string + appendfeatures []string + clearedFields map[string]struct{} + done bool + oldValue func(context.Context) (*OrgSubscriptionHistory, error) + predicates []predicate.OrgSubscriptionHistory +} + +var _ ent.Mutation = (*OrgSubscriptionHistoryMutation)(nil) + +// orgsubscriptionhistoryOption allows management of the mutation configuration using functional options. +type orgsubscriptionhistoryOption func(*OrgSubscriptionHistoryMutation) + +// newOrgSubscriptionHistoryMutation creates new mutation for the OrgSubscriptionHistory entity. +func newOrgSubscriptionHistoryMutation(c config, op Op, opts ...orgsubscriptionhistoryOption) *OrgSubscriptionHistoryMutation { + m := &OrgSubscriptionHistoryMutation{ + config: c, + op: op, + typ: TypeOrgSubscriptionHistory, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withOrgSubscriptionHistoryID sets the ID field of the mutation. +func withOrgSubscriptionHistoryID(id string) orgsubscriptionhistoryOption { + return func(m *OrgSubscriptionHistoryMutation) { + var ( + err error + once sync.Once + value *OrgSubscriptionHistory + ) + m.oldValue = func(ctx context.Context) (*OrgSubscriptionHistory, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().OrgSubscriptionHistory.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withOrgSubscriptionHistory sets the old OrgSubscriptionHistory of the mutation. +func withOrgSubscriptionHistory(node *OrgSubscriptionHistory) orgsubscriptionhistoryOption { + return func(m *OrgSubscriptionHistoryMutation) { + m.oldValue = func(context.Context) (*OrgSubscriptionHistory, error) { + return node, nil + } + m.id = &node.ID + } +} + +// Client returns a new `ent.Client` from the mutation. If the mutation was +// executed in a transaction (ent.Tx), a transactional client is returned. +func (m OrgSubscriptionHistoryMutation) Client() *Client { + client := &Client{config: m.config} + client.init() + return client +} + +// Tx returns an `ent.Tx` for mutations that were executed in transactions; +// it returns an error otherwise. +func (m OrgSubscriptionHistoryMutation) Tx() (*Tx, error) { + if _, ok := m.driver.(*txDriver); !ok { + return nil, errors.New("generated: mutation is not running in a transaction") + } + tx := &Tx{config: m.config} + tx.init() + return tx, nil +} + +// SetID sets the value of the id field. Note that this +// operation is only accepted on creation of OrgSubscriptionHistory entities. +func (m *OrgSubscriptionHistoryMutation) SetID(id string) { + m.id = &id +} + +// ID returns the ID value in the mutation. Note that the ID is only available +// if it was provided to the builder or after it was returned from the database. +func (m *OrgSubscriptionHistoryMutation) ID() (id string, exists bool) { + if m.id == nil { + return + } + return *m.id, true +} + +// IDs queries the database and returns the entity ids that match the mutation's predicate. +// That means, if the mutation is applied within a transaction with an isolation level such +// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated +// or updated by the mutation. +func (m *OrgSubscriptionHistoryMutation) IDs(ctx context.Context) ([]string, error) { + switch { + case m.op.Is(OpUpdateOne | OpDeleteOne): + id, exists := m.ID() + if exists { + return []string{id}, nil + } + fallthrough + case m.op.Is(OpUpdate | OpDelete): + return m.Client().OrgSubscriptionHistory.Query().Where(m.predicates...).IDs(ctx) + default: + return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op) + } +} + +// SetHistoryTime sets the "history_time" field. +func (m *OrgSubscriptionHistoryMutation) SetHistoryTime(t time.Time) { + m.history_time = &t +} + +// HistoryTime returns the value of the "history_time" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) HistoryTime() (r time.Time, exists bool) { + v := m.history_time + if v == nil { + return + } + return *v, true +} + +// OldHistoryTime returns the old "history_time" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldHistoryTime(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldHistoryTime is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldHistoryTime requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldHistoryTime: %w", err) + } + return oldValue.HistoryTime, nil +} + +// ResetHistoryTime resets all changes to the "history_time" field. +func (m *OrgSubscriptionHistoryMutation) ResetHistoryTime() { + m.history_time = nil +} + +// SetRef sets the "ref" field. +func (m *OrgSubscriptionHistoryMutation) SetRef(s string) { + m.ref = &s +} + +// Ref returns the value of the "ref" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) Ref() (r string, exists bool) { + v := m.ref + if v == nil { + return + } + return *v, true +} + +// OldRef returns the old "ref" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldRef(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldRef is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldRef requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldRef: %w", err) + } + return oldValue.Ref, nil +} + +// ClearRef clears the value of the "ref" field. +func (m *OrgSubscriptionHistoryMutation) ClearRef() { + m.ref = nil + m.clearedFields[orgsubscriptionhistory.FieldRef] = struct{}{} +} + +// RefCleared returns if the "ref" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) RefCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldRef] + return ok +} + +// ResetRef resets all changes to the "ref" field. +func (m *OrgSubscriptionHistoryMutation) ResetRef() { + m.ref = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldRef) +} + +// SetOperation sets the "operation" field. +func (m *OrgSubscriptionHistoryMutation) SetOperation(ht history.OpType) { + m.operation = &ht +} + +// Operation returns the value of the "operation" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) Operation() (r history.OpType, exists bool) { + v := m.operation + if v == nil { + return + } + return *v, true +} + +// OldOperation returns the old "operation" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldOperation(ctx context.Context) (v history.OpType, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldOperation is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldOperation requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldOperation: %w", err) + } + return oldValue.Operation, nil +} + +// ResetOperation resets all changes to the "operation" field. +func (m *OrgSubscriptionHistoryMutation) ResetOperation() { + m.operation = nil +} + +// SetCreatedAt sets the "created_at" field. +func (m *OrgSubscriptionHistoryMutation) SetCreatedAt(t time.Time) { + m.created_at = &t +} + +// CreatedAt returns the value of the "created_at" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) CreatedAt() (r time.Time, exists bool) { + v := m.created_at + if v == nil { + return + } + return *v, true +} + +// OldCreatedAt returns the old "created_at" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCreatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err) + } + return oldValue.CreatedAt, nil +} + +// ClearCreatedAt clears the value of the "created_at" field. +func (m *OrgSubscriptionHistoryMutation) ClearCreatedAt() { + m.created_at = nil + m.clearedFields[orgsubscriptionhistory.FieldCreatedAt] = struct{}{} +} + +// CreatedAtCleared returns if the "created_at" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) CreatedAtCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldCreatedAt] + return ok +} + +// ResetCreatedAt resets all changes to the "created_at" field. +func (m *OrgSubscriptionHistoryMutation) ResetCreatedAt() { + m.created_at = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldCreatedAt) +} + +// SetUpdatedAt sets the "updated_at" field. +func (m *OrgSubscriptionHistoryMutation) SetUpdatedAt(t time.Time) { + m.updated_at = &t +} + +// UpdatedAt returns the value of the "updated_at" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) UpdatedAt() (r time.Time, exists bool) { + v := m.updated_at + if v == nil { + return + } + return *v, true +} + +// OldUpdatedAt returns the old "updated_at" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUpdatedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err) + } + return oldValue.UpdatedAt, nil +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (m *OrgSubscriptionHistoryMutation) ClearUpdatedAt() { + m.updated_at = nil + m.clearedFields[orgsubscriptionhistory.FieldUpdatedAt] = struct{}{} +} + +// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) UpdatedAtCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldUpdatedAt] + return ok +} + +// ResetUpdatedAt resets all changes to the "updated_at" field. +func (m *OrgSubscriptionHistoryMutation) ResetUpdatedAt() { + m.updated_at = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldUpdatedAt) +} + +// SetCreatedBy sets the "created_by" field. +func (m *OrgSubscriptionHistoryMutation) SetCreatedBy(s string) { + m.created_by = &s +} + +// CreatedBy returns the value of the "created_by" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) CreatedBy() (r string, exists bool) { + v := m.created_by + if v == nil { + return + } + return *v, true +} + +// OldCreatedBy returns the old "created_by" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldCreatedBy(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldCreatedBy is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldCreatedBy requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldCreatedBy: %w", err) + } + return oldValue.CreatedBy, nil +} + +// ClearCreatedBy clears the value of the "created_by" field. +func (m *OrgSubscriptionHistoryMutation) ClearCreatedBy() { + m.created_by = nil + m.clearedFields[orgsubscriptionhistory.FieldCreatedBy] = struct{}{} +} + +// CreatedByCleared returns if the "created_by" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) CreatedByCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldCreatedBy] + return ok +} + +// ResetCreatedBy resets all changes to the "created_by" field. +func (m *OrgSubscriptionHistoryMutation) ResetCreatedBy() { + m.created_by = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldCreatedBy) +} + +// SetUpdatedBy sets the "updated_by" field. +func (m *OrgSubscriptionHistoryMutation) SetUpdatedBy(s string) { + m.updated_by = &s +} + +// UpdatedBy returns the value of the "updated_by" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) UpdatedBy() (r string, exists bool) { + v := m.updated_by + if v == nil { + return + } + return *v, true +} + +// OldUpdatedBy returns the old "updated_by" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldUpdatedBy(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUpdatedBy is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUpdatedBy requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUpdatedBy: %w", err) + } + return oldValue.UpdatedBy, nil +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (m *OrgSubscriptionHistoryMutation) ClearUpdatedBy() { + m.updated_by = nil + m.clearedFields[orgsubscriptionhistory.FieldUpdatedBy] = struct{}{} +} + +// UpdatedByCleared returns if the "updated_by" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) UpdatedByCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldUpdatedBy] + return ok +} + +// ResetUpdatedBy resets all changes to the "updated_by" field. +func (m *OrgSubscriptionHistoryMutation) ResetUpdatedBy() { + m.updated_by = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldUpdatedBy) +} + +// SetMappingID sets the "mapping_id" field. +func (m *OrgSubscriptionHistoryMutation) SetMappingID(s string) { + m.mapping_id = &s +} + +// MappingID returns the value of the "mapping_id" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) MappingID() (r string, exists bool) { + v := m.mapping_id + if v == nil { + return + } + return *v, true +} + +// OldMappingID returns the old "mapping_id" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldMappingID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldMappingID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldMappingID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldMappingID: %w", err) + } + return oldValue.MappingID, nil +} + +// ResetMappingID resets all changes to the "mapping_id" field. +func (m *OrgSubscriptionHistoryMutation) ResetMappingID() { + m.mapping_id = nil +} + +// SetTags sets the "tags" field. +func (m *OrgSubscriptionHistoryMutation) SetTags(s []string) { + m.tags = &s + m.appendtags = nil +} + +// Tags returns the value of the "tags" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) Tags() (r []string, exists bool) { + v := m.tags + if v == nil { + return + } + return *v, true +} + +// OldTags returns the old "tags" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldTags(ctx context.Context) (v []string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldTags is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldTags requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldTags: %w", err) + } + return oldValue.Tags, nil +} + +// AppendTags adds s to the "tags" field. +func (m *OrgSubscriptionHistoryMutation) AppendTags(s []string) { + m.appendtags = append(m.appendtags, s...) +} + +// AppendedTags returns the list of values that were appended to the "tags" field in this mutation. +func (m *OrgSubscriptionHistoryMutation) AppendedTags() ([]string, bool) { + if len(m.appendtags) == 0 { + return nil, false + } + return m.appendtags, true +} + +// ClearTags clears the value of the "tags" field. +func (m *OrgSubscriptionHistoryMutation) ClearTags() { + m.tags = nil + m.appendtags = nil + m.clearedFields[orgsubscriptionhistory.FieldTags] = struct{}{} +} + +// TagsCleared returns if the "tags" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) TagsCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldTags] + return ok +} + +// ResetTags resets all changes to the "tags" field. +func (m *OrgSubscriptionHistoryMutation) ResetTags() { + m.tags = nil + m.appendtags = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldTags) +} + +// SetDeletedAt sets the "deleted_at" field. +func (m *OrgSubscriptionHistoryMutation) SetDeletedAt(t time.Time) { + m.deleted_at = &t +} + +// DeletedAt returns the value of the "deleted_at" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) DeletedAt() (r time.Time, exists bool) { + v := m.deleted_at + if v == nil { + return + } + return *v, true +} + +// OldDeletedAt returns the old "deleted_at" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldDeletedAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err) + } + return oldValue.DeletedAt, nil +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (m *OrgSubscriptionHistoryMutation) ClearDeletedAt() { + m.deleted_at = nil + m.clearedFields[orgsubscriptionhistory.FieldDeletedAt] = struct{}{} +} + +// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) DeletedAtCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldDeletedAt] + return ok +} + +// ResetDeletedAt resets all changes to the "deleted_at" field. +func (m *OrgSubscriptionHistoryMutation) ResetDeletedAt() { + m.deleted_at = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldDeletedAt) +} + +// SetDeletedBy sets the "deleted_by" field. +func (m *OrgSubscriptionHistoryMutation) SetDeletedBy(s string) { + m.deleted_by = &s +} + +// DeletedBy returns the value of the "deleted_by" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) DeletedBy() (r string, exists bool) { + v := m.deleted_by + if v == nil { + return + } + return *v, true +} + +// OldDeletedBy returns the old "deleted_by" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldDeletedBy(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldDeletedBy is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldDeletedBy requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldDeletedBy: %w", err) + } + return oldValue.DeletedBy, nil +} + +// ClearDeletedBy clears the value of the "deleted_by" field. +func (m *OrgSubscriptionHistoryMutation) ClearDeletedBy() { + m.deleted_by = nil + m.clearedFields[orgsubscriptionhistory.FieldDeletedBy] = struct{}{} +} + +// DeletedByCleared returns if the "deleted_by" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) DeletedByCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldDeletedBy] + return ok +} + +// ResetDeletedBy resets all changes to the "deleted_by" field. +func (m *OrgSubscriptionHistoryMutation) ResetDeletedBy() { + m.deleted_by = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldDeletedBy) +} + +// SetOwnerID sets the "owner_id" field. +func (m *OrgSubscriptionHistoryMutation) SetOwnerID(s string) { + m.owner_id = &s +} + +// OwnerID returns the value of the "owner_id" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) OwnerID() (r string, exists bool) { + v := m.owner_id + if v == nil { + return + } + return *v, true +} + +// OldOwnerID returns the old "owner_id" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldOwnerID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldOwnerID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldOwnerID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldOwnerID: %w", err) + } + return oldValue.OwnerID, nil +} + +// ClearOwnerID clears the value of the "owner_id" field. +func (m *OrgSubscriptionHistoryMutation) ClearOwnerID() { + m.owner_id = nil + m.clearedFields[orgsubscriptionhistory.FieldOwnerID] = struct{}{} +} + +// OwnerIDCleared returns if the "owner_id" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) OwnerIDCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldOwnerID] + return ok +} + +// ResetOwnerID resets all changes to the "owner_id" field. +func (m *OrgSubscriptionHistoryMutation) ResetOwnerID() { + m.owner_id = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldOwnerID) +} + +// SetStripeSubscriptionID sets the "stripe_subscription_id" field. +func (m *OrgSubscriptionHistoryMutation) SetStripeSubscriptionID(s string) { + m.stripe_subscription_id = &s +} + +// StripeSubscriptionID returns the value of the "stripe_subscription_id" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) StripeSubscriptionID() (r string, exists bool) { + v := m.stripe_subscription_id + if v == nil { + return + } + return *v, true +} + +// OldStripeSubscriptionID returns the old "stripe_subscription_id" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldStripeSubscriptionID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStripeSubscriptionID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStripeSubscriptionID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStripeSubscriptionID: %w", err) + } + return oldValue.StripeSubscriptionID, nil +} + +// ClearStripeSubscriptionID clears the value of the "stripe_subscription_id" field. +func (m *OrgSubscriptionHistoryMutation) ClearStripeSubscriptionID() { + m.stripe_subscription_id = nil + m.clearedFields[orgsubscriptionhistory.FieldStripeSubscriptionID] = struct{}{} +} + +// StripeSubscriptionIDCleared returns if the "stripe_subscription_id" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) StripeSubscriptionIDCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldStripeSubscriptionID] + return ok +} + +// ResetStripeSubscriptionID resets all changes to the "stripe_subscription_id" field. +func (m *OrgSubscriptionHistoryMutation) ResetStripeSubscriptionID() { + m.stripe_subscription_id = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldStripeSubscriptionID) +} + +// SetProductTier sets the "product_tier" field. +func (m *OrgSubscriptionHistoryMutation) SetProductTier(s string) { + m.product_tier = &s +} + +// ProductTier returns the value of the "product_tier" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) ProductTier() (r string, exists bool) { + v := m.product_tier + if v == nil { + return + } + return *v, true +} + +// OldProductTier returns the old "product_tier" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldProductTier(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldProductTier is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldProductTier requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldProductTier: %w", err) + } + return oldValue.ProductTier, nil +} + +// ClearProductTier clears the value of the "product_tier" field. +func (m *OrgSubscriptionHistoryMutation) ClearProductTier() { + m.product_tier = nil + m.clearedFields[orgsubscriptionhistory.FieldProductTier] = struct{}{} +} + +// ProductTierCleared returns if the "product_tier" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) ProductTierCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldProductTier] + return ok +} + +// ResetProductTier resets all changes to the "product_tier" field. +func (m *OrgSubscriptionHistoryMutation) ResetProductTier() { + m.product_tier = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldProductTier) +} + +// SetStripeProductTierID sets the "stripe_product_tier_id" field. +func (m *OrgSubscriptionHistoryMutation) SetStripeProductTierID(s string) { + m.stripe_product_tier_id = &s +} + +// StripeProductTierID returns the value of the "stripe_product_tier_id" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) StripeProductTierID() (r string, exists bool) { + v := m.stripe_product_tier_id + if v == nil { + return + } + return *v, true +} + +// OldStripeProductTierID returns the old "stripe_product_tier_id" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldStripeProductTierID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStripeProductTierID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStripeProductTierID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStripeProductTierID: %w", err) + } + return oldValue.StripeProductTierID, nil +} + +// ClearStripeProductTierID clears the value of the "stripe_product_tier_id" field. +func (m *OrgSubscriptionHistoryMutation) ClearStripeProductTierID() { + m.stripe_product_tier_id = nil + m.clearedFields[orgsubscriptionhistory.FieldStripeProductTierID] = struct{}{} +} + +// StripeProductTierIDCleared returns if the "stripe_product_tier_id" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) StripeProductTierIDCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldStripeProductTierID] + return ok +} + +// ResetStripeProductTierID resets all changes to the "stripe_product_tier_id" field. +func (m *OrgSubscriptionHistoryMutation) ResetStripeProductTierID() { + m.stripe_product_tier_id = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldStripeProductTierID) +} + +// SetStripeSubscriptionStatus sets the "stripe_subscription_status" field. +func (m *OrgSubscriptionHistoryMutation) SetStripeSubscriptionStatus(s string) { + m.stripe_subscription_status = &s +} + +// StripeSubscriptionStatus returns the value of the "stripe_subscription_status" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) StripeSubscriptionStatus() (r string, exists bool) { + v := m.stripe_subscription_status + if v == nil { + return + } + return *v, true +} + +// OldStripeSubscriptionStatus returns the old "stripe_subscription_status" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldStripeSubscriptionStatus(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStripeSubscriptionStatus is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStripeSubscriptionStatus requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStripeSubscriptionStatus: %w", err) + } + return oldValue.StripeSubscriptionStatus, nil +} + +// ClearStripeSubscriptionStatus clears the value of the "stripe_subscription_status" field. +func (m *OrgSubscriptionHistoryMutation) ClearStripeSubscriptionStatus() { + m.stripe_subscription_status = nil + m.clearedFields[orgsubscriptionhistory.FieldStripeSubscriptionStatus] = struct{}{} +} + +// StripeSubscriptionStatusCleared returns if the "stripe_subscription_status" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) StripeSubscriptionStatusCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldStripeSubscriptionStatus] + return ok +} + +// ResetStripeSubscriptionStatus resets all changes to the "stripe_subscription_status" field. +func (m *OrgSubscriptionHistoryMutation) ResetStripeSubscriptionStatus() { + m.stripe_subscription_status = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldStripeSubscriptionStatus) +} + +// SetActive sets the "active" field. +func (m *OrgSubscriptionHistoryMutation) SetActive(b bool) { + m.active = &b +} + +// Active returns the value of the "active" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) Active() (r bool, exists bool) { + v := m.active + if v == nil { + return + } + return *v, true +} + +// OldActive returns the old "active" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldActive(ctx context.Context) (v bool, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldActive is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldActive requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldActive: %w", err) + } + return oldValue.Active, nil +} + +// ResetActive resets all changes to the "active" field. +func (m *OrgSubscriptionHistoryMutation) ResetActive() { + m.active = nil +} + +// SetStripeCustomerID sets the "stripe_customer_id" field. +func (m *OrgSubscriptionHistoryMutation) SetStripeCustomerID(s string) { + m.stripe_customer_id = &s +} + +// StripeCustomerID returns the value of the "stripe_customer_id" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) StripeCustomerID() (r string, exists bool) { + v := m.stripe_customer_id + if v == nil { + return + } + return *v, true +} + +// OldStripeCustomerID returns the old "stripe_customer_id" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldStripeCustomerID(ctx context.Context) (v string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldStripeCustomerID is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldStripeCustomerID requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldStripeCustomerID: %w", err) + } + return oldValue.StripeCustomerID, nil +} + +// ClearStripeCustomerID clears the value of the "stripe_customer_id" field. +func (m *OrgSubscriptionHistoryMutation) ClearStripeCustomerID() { + m.stripe_customer_id = nil + m.clearedFields[orgsubscriptionhistory.FieldStripeCustomerID] = struct{}{} +} + +// StripeCustomerIDCleared returns if the "stripe_customer_id" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) StripeCustomerIDCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldStripeCustomerID] + return ok +} + +// ResetStripeCustomerID resets all changes to the "stripe_customer_id" field. +func (m *OrgSubscriptionHistoryMutation) ResetStripeCustomerID() { + m.stripe_customer_id = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldStripeCustomerID) +} + +// SetExpiresAt sets the "expires_at" field. +func (m *OrgSubscriptionHistoryMutation) SetExpiresAt(t time.Time) { + m.expires_at = &t +} + +// ExpiresAt returns the value of the "expires_at" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) ExpiresAt() (r time.Time, exists bool) { + v := m.expires_at + if v == nil { + return + } + return *v, true +} + +// OldExpiresAt returns the old "expires_at" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldExpiresAt(ctx context.Context) (v *time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldExpiresAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldExpiresAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldExpiresAt: %w", err) + } + return oldValue.ExpiresAt, nil +} + +// ClearExpiresAt clears the value of the "expires_at" field. +func (m *OrgSubscriptionHistoryMutation) ClearExpiresAt() { + m.expires_at = nil + m.clearedFields[orgsubscriptionhistory.FieldExpiresAt] = struct{}{} +} + +// ExpiresAtCleared returns if the "expires_at" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) ExpiresAtCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldExpiresAt] + return ok +} + +// ResetExpiresAt resets all changes to the "expires_at" field. +func (m *OrgSubscriptionHistoryMutation) ResetExpiresAt() { + m.expires_at = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldExpiresAt) +} + +// SetFeatures sets the "features" field. +func (m *OrgSubscriptionHistoryMutation) SetFeatures(s []string) { + m.features = &s + m.appendfeatures = nil +} + +// Features returns the value of the "features" field in the mutation. +func (m *OrgSubscriptionHistoryMutation) Features() (r []string, exists bool) { + v := m.features + if v == nil { + return + } + return *v, true +} + +// OldFeatures returns the old "features" field's value of the OrgSubscriptionHistory entity. +// If the OrgSubscriptionHistory object wasn't provided to the builder, the object is fetched from the database. +// An error is returned if the mutation operation is not UpdateOne, or the database query fails. +func (m *OrgSubscriptionHistoryMutation) OldFeatures(ctx context.Context) (v []string, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldFeatures is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldFeatures requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldFeatures: %w", err) + } + return oldValue.Features, nil +} + +// AppendFeatures adds s to the "features" field. +func (m *OrgSubscriptionHistoryMutation) AppendFeatures(s []string) { + m.appendfeatures = append(m.appendfeatures, s...) +} + +// AppendedFeatures returns the list of values that were appended to the "features" field in this mutation. +func (m *OrgSubscriptionHistoryMutation) AppendedFeatures() ([]string, bool) { + if len(m.appendfeatures) == 0 { + return nil, false + } + return m.appendfeatures, true +} + +// ClearFeatures clears the value of the "features" field. +func (m *OrgSubscriptionHistoryMutation) ClearFeatures() { + m.features = nil + m.appendfeatures = nil + m.clearedFields[orgsubscriptionhistory.FieldFeatures] = struct{}{} +} + +// FeaturesCleared returns if the "features" field was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) FeaturesCleared() bool { + _, ok := m.clearedFields[orgsubscriptionhistory.FieldFeatures] + return ok +} + +// ResetFeatures resets all changes to the "features" field. +func (m *OrgSubscriptionHistoryMutation) ResetFeatures() { + m.features = nil + m.appendfeatures = nil + delete(m.clearedFields, orgsubscriptionhistory.FieldFeatures) +} + +// Where appends a list predicates to the OrgSubscriptionHistoryMutation builder. +func (m *OrgSubscriptionHistoryMutation) Where(ps ...predicate.OrgSubscriptionHistory) { + m.predicates = append(m.predicates, ps...) +} + +// WhereP appends storage-level predicates to the OrgSubscriptionHistoryMutation builder. Using this method, +// users can use type-assertion to append predicates that do not depend on any generated package. +func (m *OrgSubscriptionHistoryMutation) WhereP(ps ...func(*sql.Selector)) { + p := make([]predicate.OrgSubscriptionHistory, len(ps)) + for i := range ps { + p[i] = ps[i] + } + m.Where(p...) +} + +// Op returns the operation name. +func (m *OrgSubscriptionHistoryMutation) Op() Op { + return m.op +} + +// SetOp allows setting the mutation operation. +func (m *OrgSubscriptionHistoryMutation) SetOp(op Op) { + m.op = op +} + +// Type returns the node type of this mutation (OrgSubscriptionHistory). +func (m *OrgSubscriptionHistoryMutation) Type() string { + return m.typ +} + +// Fields returns all fields that were changed during this mutation. Note that in +// order to get all numeric fields that were incremented/decremented, call +// AddedFields(). +func (m *OrgSubscriptionHistoryMutation) Fields() []string { + fields := make([]string, 0, 20) + if m.history_time != nil { + fields = append(fields, orgsubscriptionhistory.FieldHistoryTime) + } + if m.ref != nil { + fields = append(fields, orgsubscriptionhistory.FieldRef) + } + if m.operation != nil { + fields = append(fields, orgsubscriptionhistory.FieldOperation) + } + if m.created_at != nil { + fields = append(fields, orgsubscriptionhistory.FieldCreatedAt) + } + if m.updated_at != nil { + fields = append(fields, orgsubscriptionhistory.FieldUpdatedAt) + } + if m.created_by != nil { + fields = append(fields, orgsubscriptionhistory.FieldCreatedBy) + } + if m.updated_by != nil { + fields = append(fields, orgsubscriptionhistory.FieldUpdatedBy) + } + if m.mapping_id != nil { + fields = append(fields, orgsubscriptionhistory.FieldMappingID) + } + if m.tags != nil { + fields = append(fields, orgsubscriptionhistory.FieldTags) + } + if m.deleted_at != nil { + fields = append(fields, orgsubscriptionhistory.FieldDeletedAt) + } + if m.deleted_by != nil { + fields = append(fields, orgsubscriptionhistory.FieldDeletedBy) + } + if m.owner_id != nil { + fields = append(fields, orgsubscriptionhistory.FieldOwnerID) + } + if m.stripe_subscription_id != nil { + fields = append(fields, orgsubscriptionhistory.FieldStripeSubscriptionID) + } + if m.product_tier != nil { + fields = append(fields, orgsubscriptionhistory.FieldProductTier) + } + if m.stripe_product_tier_id != nil { + fields = append(fields, orgsubscriptionhistory.FieldStripeProductTierID) + } + if m.stripe_subscription_status != nil { + fields = append(fields, orgsubscriptionhistory.FieldStripeSubscriptionStatus) + } + if m.active != nil { + fields = append(fields, orgsubscriptionhistory.FieldActive) + } + if m.stripe_customer_id != nil { + fields = append(fields, orgsubscriptionhistory.FieldStripeCustomerID) + } + if m.expires_at != nil { + fields = append(fields, orgsubscriptionhistory.FieldExpiresAt) + } + if m.features != nil { + fields = append(fields, orgsubscriptionhistory.FieldFeatures) + } + return fields +} + +// Field returns the value of a field with the given name. The second boolean +// return value indicates that this field was not set, or was not defined in the +// schema. +func (m *OrgSubscriptionHistoryMutation) Field(name string) (ent.Value, bool) { + switch name { + case orgsubscriptionhistory.FieldHistoryTime: + return m.HistoryTime() + case orgsubscriptionhistory.FieldRef: + return m.Ref() + case orgsubscriptionhistory.FieldOperation: + return m.Operation() + case orgsubscriptionhistory.FieldCreatedAt: + return m.CreatedAt() + case orgsubscriptionhistory.FieldUpdatedAt: + return m.UpdatedAt() + case orgsubscriptionhistory.FieldCreatedBy: + return m.CreatedBy() + case orgsubscriptionhistory.FieldUpdatedBy: + return m.UpdatedBy() + case orgsubscriptionhistory.FieldMappingID: + return m.MappingID() + case orgsubscriptionhistory.FieldTags: + return m.Tags() + case orgsubscriptionhistory.FieldDeletedAt: + return m.DeletedAt() + case orgsubscriptionhistory.FieldDeletedBy: + return m.DeletedBy() + case orgsubscriptionhistory.FieldOwnerID: + return m.OwnerID() + case orgsubscriptionhistory.FieldStripeSubscriptionID: + return m.StripeSubscriptionID() + case orgsubscriptionhistory.FieldProductTier: + return m.ProductTier() + case orgsubscriptionhistory.FieldStripeProductTierID: + return m.StripeProductTierID() + case orgsubscriptionhistory.FieldStripeSubscriptionStatus: + return m.StripeSubscriptionStatus() + case orgsubscriptionhistory.FieldActive: + return m.Active() + case orgsubscriptionhistory.FieldStripeCustomerID: + return m.StripeCustomerID() + case orgsubscriptionhistory.FieldExpiresAt: + return m.ExpiresAt() + case orgsubscriptionhistory.FieldFeatures: + return m.Features() + } + return nil, false +} + +// OldField returns the old value of the field from the database. An error is +// returned if the mutation operation is not UpdateOne, or the query to the +// database failed. +func (m *OrgSubscriptionHistoryMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case orgsubscriptionhistory.FieldHistoryTime: + return m.OldHistoryTime(ctx) + case orgsubscriptionhistory.FieldRef: + return m.OldRef(ctx) + case orgsubscriptionhistory.FieldOperation: + return m.OldOperation(ctx) + case orgsubscriptionhistory.FieldCreatedAt: + return m.OldCreatedAt(ctx) + case orgsubscriptionhistory.FieldUpdatedAt: + return m.OldUpdatedAt(ctx) + case orgsubscriptionhistory.FieldCreatedBy: + return m.OldCreatedBy(ctx) + case orgsubscriptionhistory.FieldUpdatedBy: + return m.OldUpdatedBy(ctx) + case orgsubscriptionhistory.FieldMappingID: + return m.OldMappingID(ctx) + case orgsubscriptionhistory.FieldTags: + return m.OldTags(ctx) + case orgsubscriptionhistory.FieldDeletedAt: + return m.OldDeletedAt(ctx) + case orgsubscriptionhistory.FieldDeletedBy: + return m.OldDeletedBy(ctx) + case orgsubscriptionhistory.FieldOwnerID: + return m.OldOwnerID(ctx) + case orgsubscriptionhistory.FieldStripeSubscriptionID: + return m.OldStripeSubscriptionID(ctx) + case orgsubscriptionhistory.FieldProductTier: + return m.OldProductTier(ctx) + case orgsubscriptionhistory.FieldStripeProductTierID: + return m.OldStripeProductTierID(ctx) + case orgsubscriptionhistory.FieldStripeSubscriptionStatus: + return m.OldStripeSubscriptionStatus(ctx) + case orgsubscriptionhistory.FieldActive: + return m.OldActive(ctx) + case orgsubscriptionhistory.FieldStripeCustomerID: + return m.OldStripeCustomerID(ctx) + case orgsubscriptionhistory.FieldExpiresAt: + return m.OldExpiresAt(ctx) + case orgsubscriptionhistory.FieldFeatures: + return m.OldFeatures(ctx) + } + return nil, fmt.Errorf("unknown OrgSubscriptionHistory field %s", name) +} + +// SetField sets the value of a field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *OrgSubscriptionHistoryMutation) SetField(name string, value ent.Value) error { + switch name { + case orgsubscriptionhistory.FieldHistoryTime: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetHistoryTime(v) + return nil + case orgsubscriptionhistory.FieldRef: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetRef(v) + return nil + case orgsubscriptionhistory.FieldOperation: + v, ok := value.(history.OpType) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetOperation(v) + return nil + case orgsubscriptionhistory.FieldCreatedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCreatedAt(v) + return nil + case orgsubscriptionhistory.FieldUpdatedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUpdatedAt(v) + return nil + case orgsubscriptionhistory.FieldCreatedBy: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetCreatedBy(v) + return nil + case orgsubscriptionhistory.FieldUpdatedBy: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUpdatedBy(v) + return nil + case orgsubscriptionhistory.FieldMappingID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetMappingID(v) + return nil + case orgsubscriptionhistory.FieldTags: + v, ok := value.([]string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetTags(v) + return nil + case orgsubscriptionhistory.FieldDeletedAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetDeletedAt(v) + return nil + case orgsubscriptionhistory.FieldDeletedBy: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetDeletedBy(v) + return nil + case orgsubscriptionhistory.FieldOwnerID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetOwnerID(v) + return nil + case orgsubscriptionhistory.FieldStripeSubscriptionID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStripeSubscriptionID(v) + return nil + case orgsubscriptionhistory.FieldProductTier: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetProductTier(v) + return nil + case orgsubscriptionhistory.FieldStripeProductTierID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStripeProductTierID(v) + return nil + case orgsubscriptionhistory.FieldStripeSubscriptionStatus: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStripeSubscriptionStatus(v) + return nil + case orgsubscriptionhistory.FieldActive: + v, ok := value.(bool) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetActive(v) + return nil + case orgsubscriptionhistory.FieldStripeCustomerID: + v, ok := value.(string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetStripeCustomerID(v) + return nil + case orgsubscriptionhistory.FieldExpiresAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetExpiresAt(v) + return nil + case orgsubscriptionhistory.FieldFeatures: + v, ok := value.([]string) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetFeatures(v) + return nil + } + return fmt.Errorf("unknown OrgSubscriptionHistory field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *OrgSubscriptionHistoryMutation) AddedFields() []string { + return nil +} + +// AddedField returns the numeric value that was incremented/decremented on a field +// with the given name. The second boolean return value indicates that this field +// was not set, or was not defined in the schema. +func (m *OrgSubscriptionHistoryMutation) AddedField(name string) (ent.Value, bool) { + return nil, false +} + +// AddField adds the value to the field with the given name. It returns an error if +// the field is not defined in the schema, or if the type mismatched the field +// type. +func (m *OrgSubscriptionHistoryMutation) AddField(name string, value ent.Value) error { + switch name { + } + return fmt.Errorf("unknown OrgSubscriptionHistory numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *OrgSubscriptionHistoryMutation) ClearedFields() []string { + var fields []string + if m.FieldCleared(orgsubscriptionhistory.FieldRef) { + fields = append(fields, orgsubscriptionhistory.FieldRef) + } + if m.FieldCleared(orgsubscriptionhistory.FieldCreatedAt) { + fields = append(fields, orgsubscriptionhistory.FieldCreatedAt) + } + if m.FieldCleared(orgsubscriptionhistory.FieldUpdatedAt) { + fields = append(fields, orgsubscriptionhistory.FieldUpdatedAt) + } + if m.FieldCleared(orgsubscriptionhistory.FieldCreatedBy) { + fields = append(fields, orgsubscriptionhistory.FieldCreatedBy) + } + if m.FieldCleared(orgsubscriptionhistory.FieldUpdatedBy) { + fields = append(fields, orgsubscriptionhistory.FieldUpdatedBy) + } + if m.FieldCleared(orgsubscriptionhistory.FieldTags) { + fields = append(fields, orgsubscriptionhistory.FieldTags) + } + if m.FieldCleared(orgsubscriptionhistory.FieldDeletedAt) { + fields = append(fields, orgsubscriptionhistory.FieldDeletedAt) + } + if m.FieldCleared(orgsubscriptionhistory.FieldDeletedBy) { + fields = append(fields, orgsubscriptionhistory.FieldDeletedBy) + } + if m.FieldCleared(orgsubscriptionhistory.FieldOwnerID) { + fields = append(fields, orgsubscriptionhistory.FieldOwnerID) + } + if m.FieldCleared(orgsubscriptionhistory.FieldStripeSubscriptionID) { + fields = append(fields, orgsubscriptionhistory.FieldStripeSubscriptionID) + } + if m.FieldCleared(orgsubscriptionhistory.FieldProductTier) { + fields = append(fields, orgsubscriptionhistory.FieldProductTier) + } + if m.FieldCleared(orgsubscriptionhistory.FieldStripeProductTierID) { + fields = append(fields, orgsubscriptionhistory.FieldStripeProductTierID) + } + if m.FieldCleared(orgsubscriptionhistory.FieldStripeSubscriptionStatus) { + fields = append(fields, orgsubscriptionhistory.FieldStripeSubscriptionStatus) + } + if m.FieldCleared(orgsubscriptionhistory.FieldStripeCustomerID) { + fields = append(fields, orgsubscriptionhistory.FieldStripeCustomerID) + } + if m.FieldCleared(orgsubscriptionhistory.FieldExpiresAt) { + fields = append(fields, orgsubscriptionhistory.FieldExpiresAt) + } + if m.FieldCleared(orgsubscriptionhistory.FieldFeatures) { + fields = append(fields, orgsubscriptionhistory.FieldFeatures) + } + return fields +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) FieldCleared(name string) bool { + _, ok := m.clearedFields[name] + return ok +} + +// ClearField clears the value of the field with the given name. It returns an +// error if the field is not defined in the schema. +func (m *OrgSubscriptionHistoryMutation) ClearField(name string) error { + switch name { + case orgsubscriptionhistory.FieldRef: + m.ClearRef() + return nil + case orgsubscriptionhistory.FieldCreatedAt: + m.ClearCreatedAt() + return nil + case orgsubscriptionhistory.FieldUpdatedAt: + m.ClearUpdatedAt() + return nil + case orgsubscriptionhistory.FieldCreatedBy: + m.ClearCreatedBy() + return nil + case orgsubscriptionhistory.FieldUpdatedBy: + m.ClearUpdatedBy() + return nil + case orgsubscriptionhistory.FieldTags: + m.ClearTags() + return nil + case orgsubscriptionhistory.FieldDeletedAt: + m.ClearDeletedAt() + return nil + case orgsubscriptionhistory.FieldDeletedBy: + m.ClearDeletedBy() + return nil + case orgsubscriptionhistory.FieldOwnerID: + m.ClearOwnerID() + return nil + case orgsubscriptionhistory.FieldStripeSubscriptionID: + m.ClearStripeSubscriptionID() + return nil + case orgsubscriptionhistory.FieldProductTier: + m.ClearProductTier() + return nil + case orgsubscriptionhistory.FieldStripeProductTierID: + m.ClearStripeProductTierID() + return nil + case orgsubscriptionhistory.FieldStripeSubscriptionStatus: + m.ClearStripeSubscriptionStatus() + return nil + case orgsubscriptionhistory.FieldStripeCustomerID: + m.ClearStripeCustomerID() + return nil + case orgsubscriptionhistory.FieldExpiresAt: + m.ClearExpiresAt() + return nil + case orgsubscriptionhistory.FieldFeatures: + m.ClearFeatures() + return nil + } + return fmt.Errorf("unknown OrgSubscriptionHistory nullable field %s", name) +} + +// ResetField resets all changes in the mutation for the field with the given name. +// It returns an error if the field is not defined in the schema. +func (m *OrgSubscriptionHistoryMutation) ResetField(name string) error { + switch name { + case orgsubscriptionhistory.FieldHistoryTime: + m.ResetHistoryTime() + return nil + case orgsubscriptionhistory.FieldRef: + m.ResetRef() + return nil + case orgsubscriptionhistory.FieldOperation: + m.ResetOperation() + return nil + case orgsubscriptionhistory.FieldCreatedAt: + m.ResetCreatedAt() + return nil + case orgsubscriptionhistory.FieldUpdatedAt: + m.ResetUpdatedAt() + return nil + case orgsubscriptionhistory.FieldCreatedBy: + m.ResetCreatedBy() + return nil + case orgsubscriptionhistory.FieldUpdatedBy: + m.ResetUpdatedBy() + return nil + case orgsubscriptionhistory.FieldMappingID: + m.ResetMappingID() + return nil + case orgsubscriptionhistory.FieldTags: + m.ResetTags() + return nil + case orgsubscriptionhistory.FieldDeletedAt: + m.ResetDeletedAt() + return nil + case orgsubscriptionhistory.FieldDeletedBy: + m.ResetDeletedBy() + return nil + case orgsubscriptionhistory.FieldOwnerID: + m.ResetOwnerID() + return nil + case orgsubscriptionhistory.FieldStripeSubscriptionID: + m.ResetStripeSubscriptionID() + return nil + case orgsubscriptionhistory.FieldProductTier: + m.ResetProductTier() + return nil + case orgsubscriptionhistory.FieldStripeProductTierID: + m.ResetStripeProductTierID() + return nil + case orgsubscriptionhistory.FieldStripeSubscriptionStatus: + m.ResetStripeSubscriptionStatus() + return nil + case orgsubscriptionhistory.FieldActive: + m.ResetActive() + return nil + case orgsubscriptionhistory.FieldStripeCustomerID: + m.ResetStripeCustomerID() + return nil + case orgsubscriptionhistory.FieldExpiresAt: + m.ResetExpiresAt() + return nil + case orgsubscriptionhistory.FieldFeatures: + m.ResetFeatures() + return nil + } + return fmt.Errorf("unknown OrgSubscriptionHistory field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *OrgSubscriptionHistoryMutation) AddedEdges() []string { + edges := make([]string, 0, 0) + return edges +} + +// AddedIDs returns all IDs (to other nodes) that were added for the given edge +// name in this mutation. +func (m *OrgSubscriptionHistoryMutation) AddedIDs(name string) []ent.Value { + return nil +} + +// RemovedEdges returns all edge names that were removed in this mutation. +func (m *OrgSubscriptionHistoryMutation) RemovedEdges() []string { + edges := make([]string, 0, 0) + return edges +} + +// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with +// the given name in this mutation. +func (m *OrgSubscriptionHistoryMutation) RemovedIDs(name string) []ent.Value { + return nil +} + +// ClearedEdges returns all edge names that were cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) ClearedEdges() []string { + edges := make([]string, 0, 0) + return edges +} + +// EdgeCleared returns a boolean which indicates if the edge with the given name +// was cleared in this mutation. +func (m *OrgSubscriptionHistoryMutation) EdgeCleared(name string) bool { + return false +} + +// ClearEdge clears the value of the edge with the given name. It returns an error +// if that edge is not defined in the schema. +func (m *OrgSubscriptionHistoryMutation) ClearEdge(name string) error { + return fmt.Errorf("unknown OrgSubscriptionHistory unique edge %s", name) +} + +// ResetEdge resets all changes to the edge with the given name in this mutation. +// It returns an error if the edge is not defined in the schema. +func (m *OrgSubscriptionHistoryMutation) ResetEdge(name string) error { + return fmt.Errorf("unknown OrgSubscriptionHistory edge %s", name) +} + // OrganizationMutation represents an operation that mutates the Organization nodes in the graph. type OrganizationMutation struct { config @@ -82310,6 +85585,9 @@ type OrganizationMutation struct { entitlements map[string]struct{} removedentitlements map[string]struct{} clearedentitlements bool + orgsubscriptions map[string]struct{} + removedorgsubscriptions map[string]struct{} + clearedorgsubscriptions bool organization_entitlement map[string]struct{} removedorganization_entitlement map[string]struct{} clearedorganization_entitlement bool @@ -84091,6 +87369,60 @@ func (m *OrganizationMutation) ResetEntitlements() { m.removedentitlements = nil } +// AddOrgsubscriptionIDs adds the "orgsubscriptions" edge to the OrgSubscription entity by ids. +func (m *OrganizationMutation) AddOrgsubscriptionIDs(ids ...string) { + if m.orgsubscriptions == nil { + m.orgsubscriptions = make(map[string]struct{}) + } + for i := range ids { + m.orgsubscriptions[ids[i]] = struct{}{} + } +} + +// ClearOrgsubscriptions clears the "orgsubscriptions" edge to the OrgSubscription entity. +func (m *OrganizationMutation) ClearOrgsubscriptions() { + m.clearedorgsubscriptions = true +} + +// OrgsubscriptionsCleared reports if the "orgsubscriptions" edge to the OrgSubscription entity was cleared. +func (m *OrganizationMutation) OrgsubscriptionsCleared() bool { + return m.clearedorgsubscriptions +} + +// RemoveOrgsubscriptionIDs removes the "orgsubscriptions" edge to the OrgSubscription entity by IDs. +func (m *OrganizationMutation) RemoveOrgsubscriptionIDs(ids ...string) { + if m.removedorgsubscriptions == nil { + m.removedorgsubscriptions = make(map[string]struct{}) + } + for i := range ids { + delete(m.orgsubscriptions, ids[i]) + m.removedorgsubscriptions[ids[i]] = struct{}{} + } +} + +// RemovedOrgsubscriptions returns the removed IDs of the "orgsubscriptions" edge to the OrgSubscription entity. +func (m *OrganizationMutation) RemovedOrgsubscriptionsIDs() (ids []string) { + for id := range m.removedorgsubscriptions { + ids = append(ids, id) + } + return +} + +// OrgsubscriptionsIDs returns the "orgsubscriptions" edge IDs in the mutation. +func (m *OrganizationMutation) OrgsubscriptionsIDs() (ids []string) { + for id := range m.orgsubscriptions { + ids = append(ids, id) + } + return +} + +// ResetOrgsubscriptions resets all changes to the "orgsubscriptions" edge. +func (m *OrganizationMutation) ResetOrgsubscriptions() { + m.orgsubscriptions = nil + m.clearedorgsubscriptions = false + m.removedorgsubscriptions = nil +} + // AddOrganizationEntitlementIDs adds the "organization_entitlement" edge to the Entitlement entity by ids. func (m *OrganizationMutation) AddOrganizationEntitlementIDs(ids ...string) { if m.organization_entitlement == nil { @@ -86043,7 +89375,7 @@ func (m *OrganizationMutation) ResetField(name string) error { // AddedEdges returns all edge names that were set/added in this mutation. func (m *OrganizationMutation) AddedEdges() []string { - edges := make([]string, 0, 45) + edges := make([]string, 0, 46) if m.control_creators != nil { edges = append(edges, organization.EdgeControlCreators) } @@ -86095,6 +89427,9 @@ func (m *OrganizationMutation) AddedEdges() []string { if m.entitlements != nil { edges = append(edges, organization.EdgeEntitlements) } + if m.orgsubscriptions != nil { + edges = append(edges, organization.EdgeOrgsubscriptions) + } if m.organization_entitlement != nil { edges = append(edges, organization.EdgeOrganizationEntitlement) } @@ -86284,6 +89619,12 @@ func (m *OrganizationMutation) AddedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case organization.EdgeOrgsubscriptions: + ids := make([]ent.Value, 0, len(m.orgsubscriptions)) + for id := range m.orgsubscriptions { + ids = append(ids, id) + } + return ids case organization.EdgeOrganizationEntitlement: ids := make([]ent.Value, 0, len(m.organization_entitlement)) for id := range m.organization_entitlement { @@ -86458,7 +89799,7 @@ func (m *OrganizationMutation) AddedIDs(name string) []ent.Value { // RemovedEdges returns all edge names that were removed in this mutation. func (m *OrganizationMutation) RemovedEdges() []string { - edges := make([]string, 0, 45) + edges := make([]string, 0, 46) if m.removedcontrol_creators != nil { edges = append(edges, organization.EdgeControlCreators) } @@ -86504,6 +89845,9 @@ func (m *OrganizationMutation) RemovedEdges() []string { if m.removedentitlements != nil { edges = append(edges, organization.EdgeEntitlements) } + if m.removedorgsubscriptions != nil { + edges = append(edges, organization.EdgeOrgsubscriptions) + } if m.removedorganization_entitlement != nil { edges = append(edges, organization.EdgeOrganizationEntitlement) } @@ -86685,6 +90029,12 @@ func (m *OrganizationMutation) RemovedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case organization.EdgeOrgsubscriptions: + ids := make([]ent.Value, 0, len(m.removedorgsubscriptions)) + for id := range m.removedorgsubscriptions { + ids = append(ids, id) + } + return ids case organization.EdgeOrganizationEntitlement: ids := make([]ent.Value, 0, len(m.removedorganization_entitlement)) for id := range m.removedorganization_entitlement { @@ -86859,7 +90209,7 @@ func (m *OrganizationMutation) RemovedIDs(name string) []ent.Value { // ClearedEdges returns all edge names that were cleared in this mutation. func (m *OrganizationMutation) ClearedEdges() []string { - edges := make([]string, 0, 45) + edges := make([]string, 0, 46) if m.clearedcontrol_creators { edges = append(edges, organization.EdgeControlCreators) } @@ -86911,6 +90261,9 @@ func (m *OrganizationMutation) ClearedEdges() []string { if m.clearedentitlements { edges = append(edges, organization.EdgeEntitlements) } + if m.clearedorgsubscriptions { + edges = append(edges, organization.EdgeOrgsubscriptions) + } if m.clearedorganization_entitlement { edges = append(edges, organization.EdgeOrganizationEntitlement) } @@ -87036,6 +90389,8 @@ func (m *OrganizationMutation) EdgeCleared(name string) bool { return m.cleareddocumentdata case organization.EdgeEntitlements: return m.clearedentitlements + case organization.EdgeOrgsubscriptions: + return m.clearedorgsubscriptions case organization.EdgeOrganizationEntitlement: return m.clearedorganization_entitlement case organization.EdgePersonalAccessTokens: @@ -87165,6 +90520,9 @@ func (m *OrganizationMutation) ResetEdge(name string) error { case organization.EdgeEntitlements: m.ResetEntitlements() return nil + case organization.EdgeOrgsubscriptions: + m.ResetOrgsubscriptions() + return nil case organization.EdgeOrganizationEntitlement: m.ResetOrganizationEntitlement() return nil diff --git a/internal/ent/generated/organization.go b/internal/ent/generated/organization.go index befaaea6..f57fad0e 100644 --- a/internal/ent/generated/organization.go +++ b/internal/ent/generated/organization.go @@ -91,6 +91,8 @@ type OrganizationEdges struct { Documentdata []*DocumentData `json:"documentdata,omitempty"` // Entitlements holds the value of the entitlements edge. Entitlements []*Entitlement `json:"entitlements,omitempty"` + // Orgsubscriptions holds the value of the orgsubscriptions edge. + Orgsubscriptions []*OrgSubscription `json:"orgsubscriptions,omitempty"` // OrganizationEntitlement holds the value of the organization_entitlement edge. OrganizationEntitlement []*Entitlement `json:"organization_entitlement,omitempty"` // PersonalAccessTokens holds the value of the personal_access_tokens edge. @@ -149,9 +151,9 @@ type OrganizationEdges struct { Members []*OrgMembership `json:"members,omitempty"` // loadedTypes holds the information for reporting if a // type was loaded (or requested) in eager-loading or not. - loadedTypes [45]bool + loadedTypes [46]bool // totalCount holds the count of the edges above. - totalCount [45]map[string]int + totalCount [46]map[string]int namedControlCreators map[string][]*Group namedControlObjectiveCreators map[string][]*Group @@ -168,6 +170,7 @@ type OrganizationEdges struct { namedIntegrations map[string][]*Integration namedDocumentdata map[string][]*DocumentData namedEntitlements map[string][]*Entitlement + namedOrgsubscriptions map[string][]*OrgSubscription namedOrganizationEntitlement map[string][]*Entitlement namedPersonalAccessTokens map[string][]*PersonalAccessToken namedAPITokens map[string][]*APIToken @@ -355,10 +358,19 @@ func (e OrganizationEdges) EntitlementsOrErr() ([]*Entitlement, error) { return nil, &NotLoadedError{edge: "entitlements"} } +// OrgsubscriptionsOrErr returns the Orgsubscriptions value or an error if the edge +// was not loaded in eager-loading. +func (e OrganizationEdges) OrgsubscriptionsOrErr() ([]*OrgSubscription, error) { + if e.loadedTypes[17] { + return e.Orgsubscriptions, nil + } + return nil, &NotLoadedError{edge: "orgsubscriptions"} +} + // OrganizationEntitlementOrErr returns the OrganizationEntitlement value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) OrganizationEntitlementOrErr() ([]*Entitlement, error) { - if e.loadedTypes[17] { + if e.loadedTypes[18] { return e.OrganizationEntitlement, nil } return nil, &NotLoadedError{edge: "organization_entitlement"} @@ -367,7 +379,7 @@ func (e OrganizationEdges) OrganizationEntitlementOrErr() ([]*Entitlement, error // PersonalAccessTokensOrErr returns the PersonalAccessTokens value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) PersonalAccessTokensOrErr() ([]*PersonalAccessToken, error) { - if e.loadedTypes[18] { + if e.loadedTypes[19] { return e.PersonalAccessTokens, nil } return nil, &NotLoadedError{edge: "personal_access_tokens"} @@ -376,7 +388,7 @@ func (e OrganizationEdges) PersonalAccessTokensOrErr() ([]*PersonalAccessToken, // APITokensOrErr returns the APITokens value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) APITokensOrErr() ([]*APIToken, error) { - if e.loadedTypes[19] { + if e.loadedTypes[20] { return e.APITokens, nil } return nil, &NotLoadedError{edge: "api_tokens"} @@ -385,7 +397,7 @@ func (e OrganizationEdges) APITokensOrErr() ([]*APIToken, error) { // OauthproviderOrErr returns the Oauthprovider value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) OauthproviderOrErr() ([]*OauthProvider, error) { - if e.loadedTypes[20] { + if e.loadedTypes[21] { return e.Oauthprovider, nil } return nil, &NotLoadedError{edge: "oauthprovider"} @@ -394,7 +406,7 @@ func (e OrganizationEdges) OauthproviderOrErr() ([]*OauthProvider, error) { // UsersOrErr returns the Users value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) UsersOrErr() ([]*User, error) { - if e.loadedTypes[21] { + if e.loadedTypes[22] { return e.Users, nil } return nil, &NotLoadedError{edge: "users"} @@ -403,7 +415,7 @@ func (e OrganizationEdges) UsersOrErr() ([]*User, error) { // InvitesOrErr returns the Invites value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) InvitesOrErr() ([]*Invite, error) { - if e.loadedTypes[22] { + if e.loadedTypes[23] { return e.Invites, nil } return nil, &NotLoadedError{edge: "invites"} @@ -412,7 +424,7 @@ func (e OrganizationEdges) InvitesOrErr() ([]*Invite, error) { // SubscribersOrErr returns the Subscribers value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) SubscribersOrErr() ([]*Subscriber, error) { - if e.loadedTypes[23] { + if e.loadedTypes[24] { return e.Subscribers, nil } return nil, &NotLoadedError{edge: "subscribers"} @@ -421,7 +433,7 @@ func (e OrganizationEdges) SubscribersOrErr() ([]*Subscriber, error) { // WebhooksOrErr returns the Webhooks value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) WebhooksOrErr() ([]*Webhook, error) { - if e.loadedTypes[24] { + if e.loadedTypes[25] { return e.Webhooks, nil } return nil, &NotLoadedError{edge: "webhooks"} @@ -430,7 +442,7 @@ func (e OrganizationEdges) WebhooksOrErr() ([]*Webhook, error) { // EventsOrErr returns the Events value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) EventsOrErr() ([]*Event, error) { - if e.loadedTypes[25] { + if e.loadedTypes[26] { return e.Events, nil } return nil, &NotLoadedError{edge: "events"} @@ -439,7 +451,7 @@ func (e OrganizationEdges) EventsOrErr() ([]*Event, error) { // SecretsOrErr returns the Secrets value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) SecretsOrErr() ([]*Hush, error) { - if e.loadedTypes[26] { + if e.loadedTypes[27] { return e.Secrets, nil } return nil, &NotLoadedError{edge: "secrets"} @@ -448,7 +460,7 @@ func (e OrganizationEdges) SecretsOrErr() ([]*Hush, error) { // FeaturesOrErr returns the Features value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) FeaturesOrErr() ([]*Feature, error) { - if e.loadedTypes[27] { + if e.loadedTypes[28] { return e.Features, nil } return nil, &NotLoadedError{edge: "features"} @@ -457,7 +469,7 @@ func (e OrganizationEdges) FeaturesOrErr() ([]*Feature, error) { // FilesOrErr returns the Files value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) FilesOrErr() ([]*File, error) { - if e.loadedTypes[28] { + if e.loadedTypes[29] { return e.Files, nil } return nil, &NotLoadedError{edge: "files"} @@ -466,7 +478,7 @@ func (e OrganizationEdges) FilesOrErr() ([]*File, error) { // EntitlementplansOrErr returns the Entitlementplans value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) EntitlementplansOrErr() ([]*EntitlementPlan, error) { - if e.loadedTypes[29] { + if e.loadedTypes[30] { return e.Entitlementplans, nil } return nil, &NotLoadedError{edge: "entitlementplans"} @@ -475,7 +487,7 @@ func (e OrganizationEdges) EntitlementplansOrErr() ([]*EntitlementPlan, error) { // EntitlementplanfeaturesOrErr returns the Entitlementplanfeatures value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) EntitlementplanfeaturesOrErr() ([]*EntitlementPlanFeature, error) { - if e.loadedTypes[30] { + if e.loadedTypes[31] { return e.Entitlementplanfeatures, nil } return nil, &NotLoadedError{edge: "entitlementplanfeatures"} @@ -484,7 +496,7 @@ func (e OrganizationEdges) EntitlementplanfeaturesOrErr() ([]*EntitlementPlanFea // EntitiesOrErr returns the Entities value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) EntitiesOrErr() ([]*Entity, error) { - if e.loadedTypes[31] { + if e.loadedTypes[32] { return e.Entities, nil } return nil, &NotLoadedError{edge: "entities"} @@ -493,7 +505,7 @@ func (e OrganizationEdges) EntitiesOrErr() ([]*Entity, error) { // EntitytypesOrErr returns the Entitytypes value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) EntitytypesOrErr() ([]*EntityType, error) { - if e.loadedTypes[32] { + if e.loadedTypes[33] { return e.Entitytypes, nil } return nil, &NotLoadedError{edge: "entitytypes"} @@ -502,7 +514,7 @@ func (e OrganizationEdges) EntitytypesOrErr() ([]*EntityType, error) { // ContactsOrErr returns the Contacts value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) ContactsOrErr() ([]*Contact, error) { - if e.loadedTypes[33] { + if e.loadedTypes[34] { return e.Contacts, nil } return nil, &NotLoadedError{edge: "contacts"} @@ -511,7 +523,7 @@ func (e OrganizationEdges) ContactsOrErr() ([]*Contact, error) { // NotesOrErr returns the Notes value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) NotesOrErr() ([]*Note, error) { - if e.loadedTypes[34] { + if e.loadedTypes[35] { return e.Notes, nil } return nil, &NotLoadedError{edge: "notes"} @@ -520,7 +532,7 @@ func (e OrganizationEdges) NotesOrErr() ([]*Note, error) { // TasksOrErr returns the Tasks value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) TasksOrErr() ([]*Task, error) { - if e.loadedTypes[35] { + if e.loadedTypes[36] { return e.Tasks, nil } return nil, &NotLoadedError{edge: "tasks"} @@ -529,7 +541,7 @@ func (e OrganizationEdges) TasksOrErr() ([]*Task, error) { // ProgramsOrErr returns the Programs value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) ProgramsOrErr() ([]*Program, error) { - if e.loadedTypes[36] { + if e.loadedTypes[37] { return e.Programs, nil } return nil, &NotLoadedError{edge: "programs"} @@ -538,7 +550,7 @@ func (e OrganizationEdges) ProgramsOrErr() ([]*Program, error) { // ProceduresOrErr returns the Procedures value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) ProceduresOrErr() ([]*Procedure, error) { - if e.loadedTypes[37] { + if e.loadedTypes[38] { return e.Procedures, nil } return nil, &NotLoadedError{edge: "procedures"} @@ -547,7 +559,7 @@ func (e OrganizationEdges) ProceduresOrErr() ([]*Procedure, error) { // InternalpoliciesOrErr returns the Internalpolicies value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) InternalpoliciesOrErr() ([]*InternalPolicy, error) { - if e.loadedTypes[38] { + if e.loadedTypes[39] { return e.Internalpolicies, nil } return nil, &NotLoadedError{edge: "internalpolicies"} @@ -556,7 +568,7 @@ func (e OrganizationEdges) InternalpoliciesOrErr() ([]*InternalPolicy, error) { // RisksOrErr returns the Risks value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) RisksOrErr() ([]*Risk, error) { - if e.loadedTypes[39] { + if e.loadedTypes[40] { return e.Risks, nil } return nil, &NotLoadedError{edge: "risks"} @@ -565,7 +577,7 @@ func (e OrganizationEdges) RisksOrErr() ([]*Risk, error) { // ControlobjectivesOrErr returns the Controlobjectives value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) ControlobjectivesOrErr() ([]*ControlObjective, error) { - if e.loadedTypes[40] { + if e.loadedTypes[41] { return e.Controlobjectives, nil } return nil, &NotLoadedError{edge: "controlobjectives"} @@ -574,7 +586,7 @@ func (e OrganizationEdges) ControlobjectivesOrErr() ([]*ControlObjective, error) // NarrativesOrErr returns the Narratives value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) NarrativesOrErr() ([]*Narrative, error) { - if e.loadedTypes[41] { + if e.loadedTypes[42] { return e.Narratives, nil } return nil, &NotLoadedError{edge: "narratives"} @@ -583,7 +595,7 @@ func (e OrganizationEdges) NarrativesOrErr() ([]*Narrative, error) { // ControlsOrErr returns the Controls value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) ControlsOrErr() ([]*Control, error) { - if e.loadedTypes[42] { + if e.loadedTypes[43] { return e.Controls, nil } return nil, &NotLoadedError{edge: "controls"} @@ -592,7 +604,7 @@ func (e OrganizationEdges) ControlsOrErr() ([]*Control, error) { // SubcontrolsOrErr returns the Subcontrols value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) SubcontrolsOrErr() ([]*Subcontrol, error) { - if e.loadedTypes[43] { + if e.loadedTypes[44] { return e.Subcontrols, nil } return nil, &NotLoadedError{edge: "subcontrols"} @@ -601,7 +613,7 @@ func (e OrganizationEdges) SubcontrolsOrErr() ([]*Subcontrol, error) { // MembersOrErr returns the Members value or an error if the edge // was not loaded in eager-loading. func (e OrganizationEdges) MembersOrErr() ([]*OrgMembership, error) { - if e.loadedTypes[44] { + if e.loadedTypes[45] { return e.Members, nil } return nil, &NotLoadedError{edge: "members"} @@ -832,6 +844,11 @@ func (o *Organization) QueryEntitlements() *EntitlementQuery { return NewOrganizationClient(o.config).QueryEntitlements(o) } +// QueryOrgsubscriptions queries the "orgsubscriptions" edge of the Organization entity. +func (o *Organization) QueryOrgsubscriptions() *OrgSubscriptionQuery { + return NewOrganizationClient(o.config).QueryOrgsubscriptions(o) +} + // QueryOrganizationEntitlement queries the "organization_entitlement" edge of the Organization entity. func (o *Organization) QueryOrganizationEntitlement() *EntitlementQuery { return NewOrganizationClient(o.config).QueryOrganizationEntitlement(o) @@ -1405,6 +1422,30 @@ func (o *Organization) appendNamedEntitlements(name string, edges ...*Entitlemen } } +// NamedOrgsubscriptions returns the Orgsubscriptions named value or an error if the edge was not +// loaded in eager-loading with this name. +func (o *Organization) NamedOrgsubscriptions(name string) ([]*OrgSubscription, error) { + if o.Edges.namedOrgsubscriptions == nil { + return nil, &NotLoadedError{edge: name} + } + nodes, ok := o.Edges.namedOrgsubscriptions[name] + if !ok { + return nil, &NotLoadedError{edge: name} + } + return nodes, nil +} + +func (o *Organization) appendNamedOrgsubscriptions(name string, edges ...*OrgSubscription) { + if o.Edges.namedOrgsubscriptions == nil { + o.Edges.namedOrgsubscriptions = make(map[string][]*OrgSubscription) + } + if len(edges) == 0 { + o.Edges.namedOrgsubscriptions[name] = []*OrgSubscription{} + } else { + o.Edges.namedOrgsubscriptions[name] = append(o.Edges.namedOrgsubscriptions[name], edges...) + } +} + // NamedOrganizationEntitlement returns the OrganizationEntitlement named value or an error if the edge was not // loaded in eager-loading with this name. func (o *Organization) NamedOrganizationEntitlement(name string) ([]*Entitlement, error) { diff --git a/internal/ent/generated/organization/organization.go b/internal/ent/generated/organization/organization.go index 0ca5ede8..9820798a 100644 --- a/internal/ent/generated/organization/organization.go +++ b/internal/ent/generated/organization/organization.go @@ -79,6 +79,8 @@ const ( EdgeDocumentdata = "documentdata" // EdgeEntitlements holds the string denoting the entitlements edge name in mutations. EdgeEntitlements = "entitlements" + // EdgeOrgsubscriptions holds the string denoting the orgsubscriptions edge name in mutations. + EdgeOrgsubscriptions = "orgsubscriptions" // EdgeOrganizationEntitlement holds the string denoting the organization_entitlement edge name in mutations. EdgeOrganizationEntitlement = "organization_entitlement" // EdgePersonalAccessTokens holds the string denoting the personal_access_tokens edge name in mutations. @@ -232,6 +234,13 @@ const ( EntitlementsInverseTable = "entitlements" // EntitlementsColumn is the table column denoting the entitlements relation/edge. EntitlementsColumn = "owner_id" + // OrgsubscriptionsTable is the table that holds the orgsubscriptions relation/edge. + OrgsubscriptionsTable = "org_subscriptions" + // OrgsubscriptionsInverseTable is the table name for the OrgSubscription entity. + // It exists in this package in order to avoid circular dependency with the "orgsubscription" package. + OrgsubscriptionsInverseTable = "org_subscriptions" + // OrgsubscriptionsColumn is the table column denoting the orgsubscriptions relation/edge. + OrgsubscriptionsColumn = "owner_id" // OrganizationEntitlementTable is the table that holds the organization_entitlement relation/edge. OrganizationEntitlementTable = "entitlements" // OrganizationEntitlementInverseTable is the table name for the Entitlement entity. @@ -833,6 +842,20 @@ func ByEntitlements(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { } } +// ByOrgsubscriptionsCount orders the results by orgsubscriptions count. +func ByOrgsubscriptionsCount(opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborsCount(s, newOrgsubscriptionsStep(), opts...) + } +} + +// ByOrgsubscriptions orders the results by orgsubscriptions terms. +func ByOrgsubscriptions(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newOrgsubscriptionsStep(), append([]sql.OrderTerm{term}, terms...)...) + } +} + // ByOrganizationEntitlementCount orders the results by organization_entitlement count. func ByOrganizationEntitlementCount(opts ...sql.OrderTermOption) OrderOption { return func(s *sql.Selector) { @@ -1343,6 +1366,13 @@ func newEntitlementsStep() *sqlgraph.Step { sqlgraph.Edge(sqlgraph.O2M, false, EntitlementsTable, EntitlementsColumn), ) } +func newOrgsubscriptionsStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(OrgsubscriptionsInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, OrgsubscriptionsTable, OrgsubscriptionsColumn), + ) +} func newOrganizationEntitlementStep() *sqlgraph.Step { return sqlgraph.NewStep( sqlgraph.From(Table, FieldID), diff --git a/internal/ent/generated/organization/where.go b/internal/ent/generated/organization/where.go index a064214a..45d0210a 100644 --- a/internal/ent/generated/organization/where.go +++ b/internal/ent/generated/organization/where.go @@ -1465,6 +1465,35 @@ func HasEntitlementsWith(preds ...predicate.Entitlement) predicate.Organization }) } +// HasOrgsubscriptions applies the HasEdge predicate on the "orgsubscriptions" edge. +func HasOrgsubscriptions() predicate.Organization { + return predicate.Organization(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, OrgsubscriptionsTable, OrgsubscriptionsColumn), + ) + schemaConfig := internal.SchemaConfigFromContext(s.Context()) + step.To.Schema = schemaConfig.OrgSubscription + step.Edge.Schema = schemaConfig.OrgSubscription + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasOrgsubscriptionsWith applies the HasEdge predicate on the "orgsubscriptions" edge with a given conditions (other predicates). +func HasOrgsubscriptionsWith(preds ...predicate.OrgSubscription) predicate.Organization { + return predicate.Organization(func(s *sql.Selector) { + step := newOrgsubscriptionsStep() + schemaConfig := internal.SchemaConfigFromContext(s.Context()) + step.To.Schema = schemaConfig.OrgSubscription + step.Edge.Schema = schemaConfig.OrgSubscription + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // HasOrganizationEntitlement applies the HasEdge predicate on the "organization_entitlement" edge. func HasOrganizationEntitlement() predicate.Organization { return predicate.Organization(func(s *sql.Selector) { diff --git a/internal/ent/generated/organization_create.go b/internal/ent/generated/organization_create.go index e1e35844..65b48d6d 100644 --- a/internal/ent/generated/organization_create.go +++ b/internal/ent/generated/organization_create.go @@ -34,6 +34,7 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organization" "github.com/theopenlane/core/internal/ent/generated/organizationsetting" "github.com/theopenlane/core/internal/ent/generated/orgmembership" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/procedure" "github.com/theopenlane/core/internal/ent/generated/program" @@ -524,6 +525,21 @@ func (oc *OrganizationCreate) AddEntitlements(e ...*Entitlement) *OrganizationCr return oc.AddEntitlementIDs(ids...) } +// AddOrgsubscriptionIDs adds the "orgsubscriptions" edge to the OrgSubscription entity by IDs. +func (oc *OrganizationCreate) AddOrgsubscriptionIDs(ids ...string) *OrganizationCreate { + oc.mutation.AddOrgsubscriptionIDs(ids...) + return oc +} + +// AddOrgsubscriptions adds the "orgsubscriptions" edges to the OrgSubscription entity. +func (oc *OrganizationCreate) AddOrgsubscriptions(o ...*OrgSubscription) *OrganizationCreate { + ids := make([]string, len(o)) + for i := range o { + ids[i] = o[i].ID + } + return oc.AddOrgsubscriptionIDs(ids...) +} + // AddOrganizationEntitlementIDs adds the "organization_entitlement" edge to the Entitlement entity by IDs. func (oc *OrganizationCreate) AddOrganizationEntitlementIDs(ids ...string) *OrganizationCreate { oc.mutation.AddOrganizationEntitlementIDs(ids...) @@ -1439,6 +1455,23 @@ func (oc *OrganizationCreate) createSpec() (*Organization, *sqlgraph.CreateSpec) } _spec.Edges = append(_spec.Edges, edge) } + if nodes := oc.mutation.OrgsubscriptionsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: organization.OrgsubscriptionsTable, + Columns: []string{organization.OrgsubscriptionsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString), + }, + } + edge.Schema = oc.schemaConfig.OrgSubscription + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } if nodes := oc.mutation.OrganizationEntitlementIDs(); len(nodes) > 0 { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, diff --git a/internal/ent/generated/organization_query.go b/internal/ent/generated/organization_query.go index 05b9a284..509330f5 100644 --- a/internal/ent/generated/organization_query.go +++ b/internal/ent/generated/organization_query.go @@ -37,6 +37,7 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organization" "github.com/theopenlane/core/internal/ent/generated/organizationsetting" "github.com/theopenlane/core/internal/ent/generated/orgmembership" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/predicate" "github.com/theopenlane/core/internal/ent/generated/procedure" @@ -76,6 +77,7 @@ type OrganizationQuery struct { withSetting *OrganizationSettingQuery withDocumentdata *DocumentDataQuery withEntitlements *EntitlementQuery + withOrgsubscriptions *OrgSubscriptionQuery withOrganizationEntitlement *EntitlementQuery withPersonalAccessTokens *PersonalAccessTokenQuery withAPITokens *APITokenQuery @@ -121,6 +123,7 @@ type OrganizationQuery struct { withNamedIntegrations map[string]*IntegrationQuery withNamedDocumentdata map[string]*DocumentDataQuery withNamedEntitlements map[string]*EntitlementQuery + withNamedOrgsubscriptions map[string]*OrgSubscriptionQuery withNamedOrganizationEntitlement map[string]*EntitlementQuery withNamedPersonalAccessTokens map[string]*PersonalAccessTokenQuery withNamedAPITokens map[string]*APITokenQuery @@ -610,6 +613,31 @@ func (oq *OrganizationQuery) QueryEntitlements() *EntitlementQuery { return query } +// QueryOrgsubscriptions chains the current query on the "orgsubscriptions" edge. +func (oq *OrganizationQuery) QueryOrgsubscriptions() *OrgSubscriptionQuery { + query := (&OrgSubscriptionClient{config: oq.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := oq.prepareQuery(ctx); err != nil { + return nil, err + } + selector := oq.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(organization.Table, organization.FieldID, selector), + sqlgraph.To(orgsubscription.Table, orgsubscription.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, organization.OrgsubscriptionsTable, organization.OrgsubscriptionsColumn), + ) + schemaConfig := oq.schemaConfig + step.To.Schema = schemaConfig.OrgSubscription + step.Edge.Schema = schemaConfig.OrgSubscription + fromU = sqlgraph.SetNeighbors(oq.driver.Dialect(), step) + return fromU, nil + } + return query +} + // QueryOrganizationEntitlement chains the current query on the "organization_entitlement" edge. func (oq *OrganizationQuery) QueryOrganizationEntitlement() *EntitlementQuery { query := (&EntitlementClient{config: oq.config}).Query() @@ -1519,6 +1547,7 @@ func (oq *OrganizationQuery) Clone() *OrganizationQuery { withSetting: oq.withSetting.Clone(), withDocumentdata: oq.withDocumentdata.Clone(), withEntitlements: oq.withEntitlements.Clone(), + withOrgsubscriptions: oq.withOrgsubscriptions.Clone(), withOrganizationEntitlement: oq.withOrganizationEntitlement.Clone(), withPersonalAccessTokens: oq.withPersonalAccessTokens.Clone(), withAPITokens: oq.withAPITokens.Clone(), @@ -1741,6 +1770,17 @@ func (oq *OrganizationQuery) WithEntitlements(opts ...func(*EntitlementQuery)) * return oq } +// WithOrgsubscriptions tells the query-builder to eager-load the nodes that are connected to +// the "orgsubscriptions" edge. The optional arguments are used to configure the query builder of the edge. +func (oq *OrganizationQuery) WithOrgsubscriptions(opts ...func(*OrgSubscriptionQuery)) *OrganizationQuery { + query := (&OrgSubscriptionClient{config: oq.config}).Query() + for _, opt := range opts { + opt(query) + } + oq.withOrgsubscriptions = query + return oq +} + // WithOrganizationEntitlement tells the query-builder to eager-load the nodes that are connected to // the "organization_entitlement" edge. The optional arguments are used to configure the query builder of the edge. func (oq *OrganizationQuery) WithOrganizationEntitlement(opts ...func(*EntitlementQuery)) *OrganizationQuery { @@ -2133,7 +2173,7 @@ func (oq *OrganizationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([] var ( nodes = []*Organization{} _spec = oq.querySpec() - loadedTypes = [45]bool{ + loadedTypes = [46]bool{ oq.withControlCreators != nil, oq.withControlObjectiveCreators != nil, oq.withGroupCreators != nil, @@ -2151,6 +2191,7 @@ func (oq *OrganizationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([] oq.withSetting != nil, oq.withDocumentdata != nil, oq.withEntitlements != nil, + oq.withOrgsubscriptions != nil, oq.withOrganizationEntitlement != nil, oq.withPersonalAccessTokens != nil, oq.withAPITokens != nil, @@ -2325,6 +2366,15 @@ func (oq *OrganizationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([] return nil, err } } + if query := oq.withOrgsubscriptions; query != nil { + if err := oq.loadOrgsubscriptions(ctx, query, nodes, + func(n *Organization) { n.Edges.Orgsubscriptions = []*OrgSubscription{} }, + func(n *Organization, e *OrgSubscription) { + n.Edges.Orgsubscriptions = append(n.Edges.Orgsubscriptions, e) + }); err != nil { + return nil, err + } + } if query := oq.withOrganizationEntitlement; query != nil { if err := oq.loadOrganizationEntitlement(ctx, query, nodes, func(n *Organization) { n.Edges.OrganizationEntitlement = []*Entitlement{} }, @@ -2638,6 +2688,13 @@ func (oq *OrganizationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([] return nil, err } } + for name, query := range oq.withNamedOrgsubscriptions { + if err := oq.loadOrgsubscriptions(ctx, query, nodes, + func(n *Organization) { n.appendNamedOrgsubscriptions(name) }, + func(n *Organization, e *OrgSubscription) { n.appendNamedOrgsubscriptions(name, e) }); err != nil { + return nil, err + } + } for name, query := range oq.withNamedOrganizationEntitlement { if err := oq.loadOrganizationEntitlement(ctx, query, nodes, func(n *Organization) { n.appendNamedOrganizationEntitlement(name) }, @@ -3637,6 +3694,36 @@ func (oq *OrganizationQuery) loadEntitlements(ctx context.Context, query *Entitl } return nil } +func (oq *OrganizationQuery) loadOrgsubscriptions(ctx context.Context, query *OrgSubscriptionQuery, nodes []*Organization, init func(*Organization), assign func(*Organization, *OrgSubscription)) error { + fks := make([]driver.Value, 0, len(nodes)) + nodeids := make(map[string]*Organization) + for i := range nodes { + fks = append(fks, nodes[i].ID) + nodeids[nodes[i].ID] = nodes[i] + if init != nil { + init(nodes[i]) + } + } + if len(query.ctx.Fields) > 0 { + query.ctx.AppendFieldOnce(orgsubscription.FieldOwnerID) + } + query.Where(predicate.OrgSubscription(func(s *sql.Selector) { + s.Where(sql.InValues(s.C(organization.OrgsubscriptionsColumn), fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.OwnerID + node, ok := nodeids[fk] + if !ok { + return fmt.Errorf(`unexpected referenced foreign-key "owner_id" returned %v for node %v`, fk, n.ID) + } + assign(node, n) + } + return nil +} func (oq *OrganizationQuery) loadOrganizationEntitlement(ctx context.Context, query *EntitlementQuery, nodes []*Organization, init func(*Organization), assign func(*Organization, *Entitlement)) error { fks := make([]driver.Value, 0, len(nodes)) nodeids := make(map[string]*Organization) @@ -4988,6 +5075,20 @@ func (oq *OrganizationQuery) WithNamedEntitlements(name string, opts ...func(*En return oq } +// WithNamedOrgsubscriptions tells the query-builder to eager-load the nodes that are connected to the "orgsubscriptions" +// edge with the given name. The optional arguments are used to configure the query builder of the edge. +func (oq *OrganizationQuery) WithNamedOrgsubscriptions(name string, opts ...func(*OrgSubscriptionQuery)) *OrganizationQuery { + query := (&OrgSubscriptionClient{config: oq.config}).Query() + for _, opt := range opts { + opt(query) + } + if oq.withNamedOrgsubscriptions == nil { + oq.withNamedOrgsubscriptions = make(map[string]*OrgSubscriptionQuery) + } + oq.withNamedOrgsubscriptions[name] = query + return oq +} + // WithNamedOrganizationEntitlement tells the query-builder to eager-load the nodes that are connected to the "organization_entitlement" // edge with the given name. The optional arguments are used to configure the query builder of the edge. func (oq *OrganizationQuery) WithNamedOrganizationEntitlement(name string, opts ...func(*EntitlementQuery)) *OrganizationQuery { diff --git a/internal/ent/generated/organization_update.go b/internal/ent/generated/organization_update.go index 72ebc87e..bbda5138 100644 --- a/internal/ent/generated/organization_update.go +++ b/internal/ent/generated/organization_update.go @@ -36,6 +36,7 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organization" "github.com/theopenlane/core/internal/ent/generated/organizationsetting" "github.com/theopenlane/core/internal/ent/generated/orgmembership" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/predicate" "github.com/theopenlane/core/internal/ent/generated/procedure" @@ -481,6 +482,21 @@ func (ou *OrganizationUpdate) AddEntitlements(e ...*Entitlement) *OrganizationUp return ou.AddEntitlementIDs(ids...) } +// AddOrgsubscriptionIDs adds the "orgsubscriptions" edge to the OrgSubscription entity by IDs. +func (ou *OrganizationUpdate) AddOrgsubscriptionIDs(ids ...string) *OrganizationUpdate { + ou.mutation.AddOrgsubscriptionIDs(ids...) + return ou +} + +// AddOrgsubscriptions adds the "orgsubscriptions" edges to the OrgSubscription entity. +func (ou *OrganizationUpdate) AddOrgsubscriptions(o ...*OrgSubscription) *OrganizationUpdate { + ids := make([]string, len(o)) + for i := range o { + ids[i] = o[i].ID + } + return ou.AddOrgsubscriptionIDs(ids...) +} + // AddOrganizationEntitlementIDs adds the "organization_entitlement" edge to the Entitlement entity by IDs. func (ou *OrganizationUpdate) AddOrganizationEntitlementIDs(ids ...string) *OrganizationUpdate { ou.mutation.AddOrganizationEntitlementIDs(ids...) @@ -1227,6 +1243,27 @@ func (ou *OrganizationUpdate) RemoveEntitlements(e ...*Entitlement) *Organizatio return ou.RemoveEntitlementIDs(ids...) } +// ClearOrgsubscriptions clears all "orgsubscriptions" edges to the OrgSubscription entity. +func (ou *OrganizationUpdate) ClearOrgsubscriptions() *OrganizationUpdate { + ou.mutation.ClearOrgsubscriptions() + return ou +} + +// RemoveOrgsubscriptionIDs removes the "orgsubscriptions" edge to OrgSubscription entities by IDs. +func (ou *OrganizationUpdate) RemoveOrgsubscriptionIDs(ids ...string) *OrganizationUpdate { + ou.mutation.RemoveOrgsubscriptionIDs(ids...) + return ou +} + +// RemoveOrgsubscriptions removes "orgsubscriptions" edges to OrgSubscription entities. +func (ou *OrganizationUpdate) RemoveOrgsubscriptions(o ...*OrgSubscription) *OrganizationUpdate { + ids := make([]string, len(o)) + for i := range o { + ids[i] = o[i].ID + } + return ou.RemoveOrgsubscriptionIDs(ids...) +} + // ClearOrganizationEntitlement clears all "organization_entitlement" edges to the Entitlement entity. func (ou *OrganizationUpdate) ClearOrganizationEntitlement() *OrganizationUpdate { ou.mutation.ClearOrganizationEntitlement() @@ -2711,6 +2748,54 @@ func (ou *OrganizationUpdate) sqlSave(ctx context.Context) (n int, err error) { } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if ou.mutation.OrgsubscriptionsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: organization.OrgsubscriptionsTable, + Columns: []string{organization.OrgsubscriptionsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString), + }, + } + edge.Schema = ou.schemaConfig.OrgSubscription + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := ou.mutation.RemovedOrgsubscriptionsIDs(); len(nodes) > 0 && !ou.mutation.OrgsubscriptionsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: organization.OrgsubscriptionsTable, + Columns: []string{organization.OrgsubscriptionsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString), + }, + } + edge.Schema = ou.schemaConfig.OrgSubscription + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := ou.mutation.OrgsubscriptionsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: organization.OrgsubscriptionsTable, + Columns: []string{organization.OrgsubscriptionsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString), + }, + } + edge.Schema = ou.schemaConfig.OrgSubscription + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if ou.mutation.OrganizationEntitlementCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, @@ -4516,6 +4601,21 @@ func (ouo *OrganizationUpdateOne) AddEntitlements(e ...*Entitlement) *Organizati return ouo.AddEntitlementIDs(ids...) } +// AddOrgsubscriptionIDs adds the "orgsubscriptions" edge to the OrgSubscription entity by IDs. +func (ouo *OrganizationUpdateOne) AddOrgsubscriptionIDs(ids ...string) *OrganizationUpdateOne { + ouo.mutation.AddOrgsubscriptionIDs(ids...) + return ouo +} + +// AddOrgsubscriptions adds the "orgsubscriptions" edges to the OrgSubscription entity. +func (ouo *OrganizationUpdateOne) AddOrgsubscriptions(o ...*OrgSubscription) *OrganizationUpdateOne { + ids := make([]string, len(o)) + for i := range o { + ids[i] = o[i].ID + } + return ouo.AddOrgsubscriptionIDs(ids...) +} + // AddOrganizationEntitlementIDs adds the "organization_entitlement" edge to the Entitlement entity by IDs. func (ouo *OrganizationUpdateOne) AddOrganizationEntitlementIDs(ids ...string) *OrganizationUpdateOne { ouo.mutation.AddOrganizationEntitlementIDs(ids...) @@ -5262,6 +5362,27 @@ func (ouo *OrganizationUpdateOne) RemoveEntitlements(e ...*Entitlement) *Organiz return ouo.RemoveEntitlementIDs(ids...) } +// ClearOrgsubscriptions clears all "orgsubscriptions" edges to the OrgSubscription entity. +func (ouo *OrganizationUpdateOne) ClearOrgsubscriptions() *OrganizationUpdateOne { + ouo.mutation.ClearOrgsubscriptions() + return ouo +} + +// RemoveOrgsubscriptionIDs removes the "orgsubscriptions" edge to OrgSubscription entities by IDs. +func (ouo *OrganizationUpdateOne) RemoveOrgsubscriptionIDs(ids ...string) *OrganizationUpdateOne { + ouo.mutation.RemoveOrgsubscriptionIDs(ids...) + return ouo +} + +// RemoveOrgsubscriptions removes "orgsubscriptions" edges to OrgSubscription entities. +func (ouo *OrganizationUpdateOne) RemoveOrgsubscriptions(o ...*OrgSubscription) *OrganizationUpdateOne { + ids := make([]string, len(o)) + for i := range o { + ids[i] = o[i].ID + } + return ouo.RemoveOrgsubscriptionIDs(ids...) +} + // ClearOrganizationEntitlement clears all "organization_entitlement" edges to the Entitlement entity. func (ouo *OrganizationUpdateOne) ClearOrganizationEntitlement() *OrganizationUpdateOne { ouo.mutation.ClearOrganizationEntitlement() @@ -6776,6 +6897,54 @@ func (ouo *OrganizationUpdateOne) sqlSave(ctx context.Context) (_node *Organizat } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if ouo.mutation.OrgsubscriptionsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: organization.OrgsubscriptionsTable, + Columns: []string{organization.OrgsubscriptionsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString), + }, + } + edge.Schema = ouo.schemaConfig.OrgSubscription + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := ouo.mutation.RemovedOrgsubscriptionsIDs(); len(nodes) > 0 && !ouo.mutation.OrgsubscriptionsCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: organization.OrgsubscriptionsTable, + Columns: []string{organization.OrgsubscriptionsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString), + }, + } + edge.Schema = ouo.schemaConfig.OrgSubscription + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := ouo.mutation.OrgsubscriptionsIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: organization.OrgsubscriptionsTable, + Columns: []string{organization.OrgsubscriptionsColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString), + }, + } + edge.Schema = ouo.schemaConfig.OrgSubscription + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if ouo.mutation.OrganizationEntitlementCleared() { edge := &sqlgraph.EdgeSpec{ Rel: sqlgraph.O2M, diff --git a/internal/ent/generated/orgsubscription.go b/internal/ent/generated/orgsubscription.go new file mode 100644 index 00000000..13147fe9 --- /dev/null +++ b/internal/ent/generated/orgsubscription.go @@ -0,0 +1,323 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "encoding/json" + "fmt" + "strings" + "time" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" + "github.com/theopenlane/core/internal/ent/generated/organization" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" +) + +// OrgSubscription is the model entity for the OrgSubscription schema. +type OrgSubscription struct { + config `json:"-"` + // ID of the ent. + ID string `json:"id,omitempty"` + // CreatedAt holds the value of the "created_at" field. + CreatedAt time.Time `json:"created_at,omitempty"` + // UpdatedAt holds the value of the "updated_at" field. + UpdatedAt time.Time `json:"updated_at,omitempty"` + // CreatedBy holds the value of the "created_by" field. + CreatedBy string `json:"created_by,omitempty"` + // UpdatedBy holds the value of the "updated_by" field. + UpdatedBy string `json:"updated_by,omitempty"` + // MappingID holds the value of the "mapping_id" field. + MappingID string `json:"mapping_id,omitempty"` + // tags associated with the object + Tags []string `json:"tags,omitempty"` + // DeletedAt holds the value of the "deleted_at" field. + DeletedAt time.Time `json:"deleted_at,omitempty"` + // DeletedBy holds the value of the "deleted_by" field. + DeletedBy string `json:"deleted_by,omitempty"` + // the organization id that owns the object + OwnerID string `json:"owner_id,omitempty"` + // the stripe subscription id + StripeSubscriptionID string `json:"stripe_subscription_id,omitempty"` + // the common name of the product tier the subscription is associated with, e.g. starter tier + ProductTier string `json:"product_tier,omitempty"` + // the product id that represents the tier in stripe + StripeProductTierID string `json:"stripe_product_tier_id,omitempty"` + // the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + StripeSubscriptionStatus string `json:"stripe_subscription_status,omitempty"` + // indicates if the subscription is active + Active bool `json:"active,omitempty"` + // the customer ID the subscription is associated to + StripeCustomerID string `json:"stripe_customer_id,omitempty"` + // the time the subscription is set to expire; only populated if subscription is cancelled + ExpiresAt *time.Time `json:"expires_at,omitempty"` + // the features associated with the subscription + Features []string `json:"features,omitempty"` + // Edges holds the relations/edges for other nodes in the graph. + // The values are being populated by the OrgSubscriptionQuery when eager-loading is set. + Edges OrgSubscriptionEdges `json:"edges"` + selectValues sql.SelectValues +} + +// OrgSubscriptionEdges holds the relations/edges for other nodes in the graph. +type OrgSubscriptionEdges struct { + // Owner holds the value of the owner edge. + Owner *Organization `json:"owner,omitempty"` + // loadedTypes holds the information for reporting if a + // type was loaded (or requested) in eager-loading or not. + loadedTypes [1]bool + // totalCount holds the count of the edges above. + totalCount [1]map[string]int +} + +// OwnerOrErr returns the Owner value or an error if the edge +// was not loaded in eager-loading, or loaded but was not found. +func (e OrgSubscriptionEdges) OwnerOrErr() (*Organization, error) { + if e.Owner != nil { + return e.Owner, nil + } else if e.loadedTypes[0] { + return nil, &NotFoundError{label: organization.Label} + } + return nil, &NotLoadedError{edge: "owner"} +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*OrgSubscription) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case orgsubscription.FieldTags, orgsubscription.FieldFeatures: + values[i] = new([]byte) + case orgsubscription.FieldActive: + values[i] = new(sql.NullBool) + case orgsubscription.FieldID, orgsubscription.FieldCreatedBy, orgsubscription.FieldUpdatedBy, orgsubscription.FieldMappingID, orgsubscription.FieldDeletedBy, orgsubscription.FieldOwnerID, orgsubscription.FieldStripeSubscriptionID, orgsubscription.FieldProductTier, orgsubscription.FieldStripeProductTierID, orgsubscription.FieldStripeSubscriptionStatus, orgsubscription.FieldStripeCustomerID: + values[i] = new(sql.NullString) + case orgsubscription.FieldCreatedAt, orgsubscription.FieldUpdatedAt, orgsubscription.FieldDeletedAt, orgsubscription.FieldExpiresAt: + values[i] = new(sql.NullTime) + default: + values[i] = new(sql.UnknownType) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the OrgSubscription fields. +func (os *OrgSubscription) assignValues(columns []string, values []any) error { + if m, n := len(values), len(columns); m < n { + return fmt.Errorf("mismatch number of scan values: %d != %d", m, n) + } + for i := range columns { + switch columns[i] { + case orgsubscription.FieldID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field id", values[i]) + } else if value.Valid { + os.ID = value.String + } + case orgsubscription.FieldCreatedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field created_at", values[i]) + } else if value.Valid { + os.CreatedAt = value.Time + } + case orgsubscription.FieldUpdatedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field updated_at", values[i]) + } else if value.Valid { + os.UpdatedAt = value.Time + } + case orgsubscription.FieldCreatedBy: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field created_by", values[i]) + } else if value.Valid { + os.CreatedBy = value.String + } + case orgsubscription.FieldUpdatedBy: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field updated_by", values[i]) + } else if value.Valid { + os.UpdatedBy = value.String + } + case orgsubscription.FieldMappingID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field mapping_id", values[i]) + } else if value.Valid { + os.MappingID = value.String + } + case orgsubscription.FieldTags: + if value, ok := values[i].(*[]byte); !ok { + return fmt.Errorf("unexpected type %T for field tags", values[i]) + } else if value != nil && len(*value) > 0 { + if err := json.Unmarshal(*value, &os.Tags); err != nil { + return fmt.Errorf("unmarshal field tags: %w", err) + } + } + case orgsubscription.FieldDeletedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field deleted_at", values[i]) + } else if value.Valid { + os.DeletedAt = value.Time + } + case orgsubscription.FieldDeletedBy: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field deleted_by", values[i]) + } else if value.Valid { + os.DeletedBy = value.String + } + case orgsubscription.FieldOwnerID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field owner_id", values[i]) + } else if value.Valid { + os.OwnerID = value.String + } + case orgsubscription.FieldStripeSubscriptionID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field stripe_subscription_id", values[i]) + } else if value.Valid { + os.StripeSubscriptionID = value.String + } + case orgsubscription.FieldProductTier: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field product_tier", values[i]) + } else if value.Valid { + os.ProductTier = value.String + } + case orgsubscription.FieldStripeProductTierID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field stripe_product_tier_id", values[i]) + } else if value.Valid { + os.StripeProductTierID = value.String + } + case orgsubscription.FieldStripeSubscriptionStatus: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field stripe_subscription_status", values[i]) + } else if value.Valid { + os.StripeSubscriptionStatus = value.String + } + case orgsubscription.FieldActive: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field active", values[i]) + } else if value.Valid { + os.Active = value.Bool + } + case orgsubscription.FieldStripeCustomerID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field stripe_customer_id", values[i]) + } else if value.Valid { + os.StripeCustomerID = value.String + } + case orgsubscription.FieldExpiresAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field expires_at", values[i]) + } else if value.Valid { + os.ExpiresAt = new(time.Time) + *os.ExpiresAt = value.Time + } + case orgsubscription.FieldFeatures: + if value, ok := values[i].(*[]byte); !ok { + return fmt.Errorf("unexpected type %T for field features", values[i]) + } else if value != nil && len(*value) > 0 { + if err := json.Unmarshal(*value, &os.Features); err != nil { + return fmt.Errorf("unmarshal field features: %w", err) + } + } + default: + os.selectValues.Set(columns[i], values[i]) + } + } + return nil +} + +// Value returns the ent.Value that was dynamically selected and assigned to the OrgSubscription. +// This includes values selected through modifiers, order, etc. +func (os *OrgSubscription) Value(name string) (ent.Value, error) { + return os.selectValues.Get(name) +} + +// QueryOwner queries the "owner" edge of the OrgSubscription entity. +func (os *OrgSubscription) QueryOwner() *OrganizationQuery { + return NewOrgSubscriptionClient(os.config).QueryOwner(os) +} + +// Update returns a builder for updating this OrgSubscription. +// Note that you need to call OrgSubscription.Unwrap() before calling this method if this OrgSubscription +// was returned from a transaction, and the transaction was committed or rolled back. +func (os *OrgSubscription) Update() *OrgSubscriptionUpdateOne { + return NewOrgSubscriptionClient(os.config).UpdateOne(os) +} + +// Unwrap unwraps the OrgSubscription entity that was returned from a transaction after it was closed, +// so that all future queries will be executed through the driver which created the transaction. +func (os *OrgSubscription) Unwrap() *OrgSubscription { + _tx, ok := os.config.driver.(*txDriver) + if !ok { + panic("generated: OrgSubscription is not a transactional entity") + } + os.config.driver = _tx.drv + return os +} + +// String implements the fmt.Stringer. +func (os *OrgSubscription) String() string { + var builder strings.Builder + builder.WriteString("OrgSubscription(") + builder.WriteString(fmt.Sprintf("id=%v, ", os.ID)) + builder.WriteString("created_at=") + builder.WriteString(os.CreatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("updated_at=") + builder.WriteString(os.UpdatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("created_by=") + builder.WriteString(os.CreatedBy) + builder.WriteString(", ") + builder.WriteString("updated_by=") + builder.WriteString(os.UpdatedBy) + builder.WriteString(", ") + builder.WriteString("mapping_id=") + builder.WriteString(os.MappingID) + builder.WriteString(", ") + builder.WriteString("tags=") + builder.WriteString(fmt.Sprintf("%v", os.Tags)) + builder.WriteString(", ") + builder.WriteString("deleted_at=") + builder.WriteString(os.DeletedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("deleted_by=") + builder.WriteString(os.DeletedBy) + builder.WriteString(", ") + builder.WriteString("owner_id=") + builder.WriteString(os.OwnerID) + builder.WriteString(", ") + builder.WriteString("stripe_subscription_id=") + builder.WriteString(os.StripeSubscriptionID) + builder.WriteString(", ") + builder.WriteString("product_tier=") + builder.WriteString(os.ProductTier) + builder.WriteString(", ") + builder.WriteString("stripe_product_tier_id=") + builder.WriteString(os.StripeProductTierID) + builder.WriteString(", ") + builder.WriteString("stripe_subscription_status=") + builder.WriteString(os.StripeSubscriptionStatus) + builder.WriteString(", ") + builder.WriteString("active=") + builder.WriteString(fmt.Sprintf("%v", os.Active)) + builder.WriteString(", ") + builder.WriteString("stripe_customer_id=") + builder.WriteString(os.StripeCustomerID) + builder.WriteString(", ") + if v := os.ExpiresAt; v != nil { + builder.WriteString("expires_at=") + builder.WriteString(v.Format(time.ANSIC)) + } + builder.WriteString(", ") + builder.WriteString("features=") + builder.WriteString(fmt.Sprintf("%v", os.Features)) + builder.WriteByte(')') + return builder.String() +} + +// OrgSubscriptions is a parsable slice of OrgSubscription. +type OrgSubscriptions []*OrgSubscription diff --git a/internal/ent/generated/orgsubscription/orgsubscription.go b/internal/ent/generated/orgsubscription/orgsubscription.go new file mode 100644 index 00000000..cedeeb8a --- /dev/null +++ b/internal/ent/generated/orgsubscription/orgsubscription.go @@ -0,0 +1,218 @@ +// Code generated by ent, DO NOT EDIT. + +package orgsubscription + +import ( + "time" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" +) + +const ( + // Label holds the string label denoting the orgsubscription type in the database. + Label = "org_subscription" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldCreatedAt holds the string denoting the created_at field in the database. + FieldCreatedAt = "created_at" + // FieldUpdatedAt holds the string denoting the updated_at field in the database. + FieldUpdatedAt = "updated_at" + // FieldCreatedBy holds the string denoting the created_by field in the database. + FieldCreatedBy = "created_by" + // FieldUpdatedBy holds the string denoting the updated_by field in the database. + FieldUpdatedBy = "updated_by" + // FieldMappingID holds the string denoting the mapping_id field in the database. + FieldMappingID = "mapping_id" + // FieldTags holds the string denoting the tags field in the database. + FieldTags = "tags" + // FieldDeletedAt holds the string denoting the deleted_at field in the database. + FieldDeletedAt = "deleted_at" + // FieldDeletedBy holds the string denoting the deleted_by field in the database. + FieldDeletedBy = "deleted_by" + // FieldOwnerID holds the string denoting the owner_id field in the database. + FieldOwnerID = "owner_id" + // FieldStripeSubscriptionID holds the string denoting the stripe_subscription_id field in the database. + FieldStripeSubscriptionID = "stripe_subscription_id" + // FieldProductTier holds the string denoting the product_tier field in the database. + FieldProductTier = "product_tier" + // FieldStripeProductTierID holds the string denoting the stripe_product_tier_id field in the database. + FieldStripeProductTierID = "stripe_product_tier_id" + // FieldStripeSubscriptionStatus holds the string denoting the stripe_subscription_status field in the database. + FieldStripeSubscriptionStatus = "stripe_subscription_status" + // FieldActive holds the string denoting the active field in the database. + FieldActive = "active" + // FieldStripeCustomerID holds the string denoting the stripe_customer_id field in the database. + FieldStripeCustomerID = "stripe_customer_id" + // FieldExpiresAt holds the string denoting the expires_at field in the database. + FieldExpiresAt = "expires_at" + // FieldFeatures holds the string denoting the features field in the database. + FieldFeatures = "features" + // EdgeOwner holds the string denoting the owner edge name in mutations. + EdgeOwner = "owner" + // Table holds the table name of the orgsubscription in the database. + Table = "org_subscriptions" + // OwnerTable is the table that holds the owner relation/edge. + OwnerTable = "org_subscriptions" + // OwnerInverseTable is the table name for the Organization entity. + // It exists in this package in order to avoid circular dependency with the "organization" package. + OwnerInverseTable = "organizations" + // OwnerColumn is the table column denoting the owner relation/edge. + OwnerColumn = "owner_id" +) + +// Columns holds all SQL columns for orgsubscription fields. +var Columns = []string{ + FieldID, + FieldCreatedAt, + FieldUpdatedAt, + FieldCreatedBy, + FieldUpdatedBy, + FieldMappingID, + FieldTags, + FieldDeletedAt, + FieldDeletedBy, + FieldOwnerID, + FieldStripeSubscriptionID, + FieldProductTier, + FieldStripeProductTierID, + FieldStripeSubscriptionStatus, + FieldActive, + FieldStripeCustomerID, + FieldExpiresAt, + FieldFeatures, +} + +// ValidColumn reports if the column name is valid (part of the table columns). +func ValidColumn(column string) bool { + for i := range Columns { + if column == Columns[i] { + return true + } + } + return false +} + +// Note that the variables below are initialized by the runtime +// package on the initialization of the application. Therefore, +// it should be imported in the main as follows: +// +// import _ "github.com/theopenlane/core/internal/ent/generated/runtime" +var ( + Hooks [3]ent.Hook + Interceptors [2]ent.Interceptor + // DefaultCreatedAt holds the default value on creation for the "created_at" field. + DefaultCreatedAt func() time.Time + // DefaultUpdatedAt holds the default value on creation for the "updated_at" field. + DefaultUpdatedAt func() time.Time + // UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field. + UpdateDefaultUpdatedAt func() time.Time + // DefaultMappingID holds the default value on creation for the "mapping_id" field. + DefaultMappingID func() string + // DefaultTags holds the default value on creation for the "tags" field. + DefaultTags []string + // OwnerIDValidator is a validator for the "owner_id" field. It is called by the builders before save. + OwnerIDValidator func(string) error + // DefaultActive holds the default value on creation for the "active" field. + DefaultActive bool + // DefaultID holds the default value on creation for the "id" field. + DefaultID func() string +) + +// OrderOption defines the ordering options for the OrgSubscription queries. +type OrderOption func(*sql.Selector) + +// ByID orders the results by the id field. +func ByID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldID, opts...).ToFunc() +} + +// ByCreatedAt orders the results by the created_at field. +func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCreatedAt, opts...).ToFunc() +} + +// ByUpdatedAt orders the results by the updated_at field. +func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc() +} + +// ByCreatedBy orders the results by the created_by field. +func ByCreatedBy(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCreatedBy, opts...).ToFunc() +} + +// ByUpdatedBy orders the results by the updated_by field. +func ByUpdatedBy(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUpdatedBy, opts...).ToFunc() +} + +// ByMappingID orders the results by the mapping_id field. +func ByMappingID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldMappingID, opts...).ToFunc() +} + +// ByDeletedAt orders the results by the deleted_at field. +func ByDeletedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldDeletedAt, opts...).ToFunc() +} + +// ByDeletedBy orders the results by the deleted_by field. +func ByDeletedBy(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldDeletedBy, opts...).ToFunc() +} + +// ByOwnerID orders the results by the owner_id field. +func ByOwnerID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldOwnerID, opts...).ToFunc() +} + +// ByStripeSubscriptionID orders the results by the stripe_subscription_id field. +func ByStripeSubscriptionID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStripeSubscriptionID, opts...).ToFunc() +} + +// ByProductTier orders the results by the product_tier field. +func ByProductTier(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldProductTier, opts...).ToFunc() +} + +// ByStripeProductTierID orders the results by the stripe_product_tier_id field. +func ByStripeProductTierID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStripeProductTierID, opts...).ToFunc() +} + +// ByStripeSubscriptionStatus orders the results by the stripe_subscription_status field. +func ByStripeSubscriptionStatus(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStripeSubscriptionStatus, opts...).ToFunc() +} + +// ByActive orders the results by the active field. +func ByActive(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldActive, opts...).ToFunc() +} + +// ByStripeCustomerID orders the results by the stripe_customer_id field. +func ByStripeCustomerID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStripeCustomerID, opts...).ToFunc() +} + +// ByExpiresAt orders the results by the expires_at field. +func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldExpiresAt, opts...).ToFunc() +} + +// ByOwnerField orders the results by owner field. +func ByOwnerField(field string, opts ...sql.OrderTermOption) OrderOption { + return func(s *sql.Selector) { + sqlgraph.OrderByNeighborTerms(s, newOwnerStep(), sql.OrderByField(field, opts...)) + } +} +func newOwnerStep() *sqlgraph.Step { + return sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(OwnerInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, OwnerTable, OwnerColumn), + ) +} diff --git a/internal/ent/generated/orgsubscription/where.go b/internal/ent/generated/orgsubscription/where.go new file mode 100644 index 00000000..84d56990 --- /dev/null +++ b/internal/ent/generated/orgsubscription/where.go @@ -0,0 +1,1157 @@ +// Code generated by ent, DO NOT EDIT. + +package orgsubscription + +import ( + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "github.com/theopenlane/core/internal/ent/generated/predicate" + + "github.com/theopenlane/core/internal/ent/generated/internal" +) + +// ID filters vertices based on their ID field. +func ID(id string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldID, id)) +} + +// IDEqualFold applies the EqualFold predicate on the ID field. +func IDEqualFold(id string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldID, id)) +} + +// IDContainsFold applies the ContainsFold predicate on the ID field. +func IDContainsFold(id string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldID, id)) +} + +// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ. +func CreatedAt(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldCreatedAt, v)) +} + +// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ. +func UpdatedAt(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// CreatedBy applies equality check predicate on the "created_by" field. It's identical to CreatedByEQ. +func CreatedBy(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldCreatedBy, v)) +} + +// UpdatedBy applies equality check predicate on the "updated_by" field. It's identical to UpdatedByEQ. +func UpdatedBy(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldUpdatedBy, v)) +} + +// MappingID applies equality check predicate on the "mapping_id" field. It's identical to MappingIDEQ. +func MappingID(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldMappingID, v)) +} + +// DeletedAt applies equality check predicate on the "deleted_at" field. It's identical to DeletedAtEQ. +func DeletedAt(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldDeletedAt, v)) +} + +// DeletedBy applies equality check predicate on the "deleted_by" field. It's identical to DeletedByEQ. +func DeletedBy(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldDeletedBy, v)) +} + +// OwnerID applies equality check predicate on the "owner_id" field. It's identical to OwnerIDEQ. +func OwnerID(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldOwnerID, v)) +} + +// StripeSubscriptionID applies equality check predicate on the "stripe_subscription_id" field. It's identical to StripeSubscriptionIDEQ. +func StripeSubscriptionID(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldStripeSubscriptionID, v)) +} + +// ProductTier applies equality check predicate on the "product_tier" field. It's identical to ProductTierEQ. +func ProductTier(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldProductTier, v)) +} + +// StripeProductTierID applies equality check predicate on the "stripe_product_tier_id" field. It's identical to StripeProductTierIDEQ. +func StripeProductTierID(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldStripeProductTierID, v)) +} + +// StripeSubscriptionStatus applies equality check predicate on the "stripe_subscription_status" field. It's identical to StripeSubscriptionStatusEQ. +func StripeSubscriptionStatus(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldStripeSubscriptionStatus, v)) +} + +// Active applies equality check predicate on the "active" field. It's identical to ActiveEQ. +func Active(v bool) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldActive, v)) +} + +// StripeCustomerID applies equality check predicate on the "stripe_customer_id" field. It's identical to StripeCustomerIDEQ. +func StripeCustomerID(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldStripeCustomerID, v)) +} + +// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ. +func ExpiresAt(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldExpiresAt, v)) +} + +// CreatedAtEQ applies the EQ predicate on the "created_at" field. +func CreatedAtEQ(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldCreatedAt, v)) +} + +// CreatedAtNEQ applies the NEQ predicate on the "created_at" field. +func CreatedAtNEQ(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldCreatedAt, v)) +} + +// CreatedAtIn applies the In predicate on the "created_at" field. +func CreatedAtIn(vs ...time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldCreatedAt, vs...)) +} + +// CreatedAtNotIn applies the NotIn predicate on the "created_at" field. +func CreatedAtNotIn(vs ...time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldCreatedAt, vs...)) +} + +// CreatedAtGT applies the GT predicate on the "created_at" field. +func CreatedAtGT(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldCreatedAt, v)) +} + +// CreatedAtGTE applies the GTE predicate on the "created_at" field. +func CreatedAtGTE(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldCreatedAt, v)) +} + +// CreatedAtLT applies the LT predicate on the "created_at" field. +func CreatedAtLT(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldCreatedAt, v)) +} + +// CreatedAtLTE applies the LTE predicate on the "created_at" field. +func CreatedAtLTE(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldCreatedAt, v)) +} + +// CreatedAtIsNil applies the IsNil predicate on the "created_at" field. +func CreatedAtIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldCreatedAt)) +} + +// CreatedAtNotNil applies the NotNil predicate on the "created_at" field. +func CreatedAtNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldCreatedAt)) +} + +// UpdatedAtEQ applies the EQ predicate on the "updated_at" field. +func UpdatedAtEQ(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field. +func UpdatedAtNEQ(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtIn applies the In predicate on the "updated_at" field. +func UpdatedAtIn(vs ...time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field. +func UpdatedAtNotIn(vs ...time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtGT applies the GT predicate on the "updated_at" field. +func UpdatedAtGT(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldUpdatedAt, v)) +} + +// UpdatedAtGTE applies the GTE predicate on the "updated_at" field. +func UpdatedAtGTE(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldUpdatedAt, v)) +} + +// UpdatedAtLT applies the LT predicate on the "updated_at" field. +func UpdatedAtLT(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldUpdatedAt, v)) +} + +// UpdatedAtLTE applies the LTE predicate on the "updated_at" field. +func UpdatedAtLTE(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldUpdatedAt, v)) +} + +// UpdatedAtIsNil applies the IsNil predicate on the "updated_at" field. +func UpdatedAtIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldUpdatedAt)) +} + +// UpdatedAtNotNil applies the NotNil predicate on the "updated_at" field. +func UpdatedAtNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldUpdatedAt)) +} + +// CreatedByEQ applies the EQ predicate on the "created_by" field. +func CreatedByEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldCreatedBy, v)) +} + +// CreatedByNEQ applies the NEQ predicate on the "created_by" field. +func CreatedByNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldCreatedBy, v)) +} + +// CreatedByIn applies the In predicate on the "created_by" field. +func CreatedByIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldCreatedBy, vs...)) +} + +// CreatedByNotIn applies the NotIn predicate on the "created_by" field. +func CreatedByNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldCreatedBy, vs...)) +} + +// CreatedByGT applies the GT predicate on the "created_by" field. +func CreatedByGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldCreatedBy, v)) +} + +// CreatedByGTE applies the GTE predicate on the "created_by" field. +func CreatedByGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldCreatedBy, v)) +} + +// CreatedByLT applies the LT predicate on the "created_by" field. +func CreatedByLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldCreatedBy, v)) +} + +// CreatedByLTE applies the LTE predicate on the "created_by" field. +func CreatedByLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldCreatedBy, v)) +} + +// CreatedByContains applies the Contains predicate on the "created_by" field. +func CreatedByContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldCreatedBy, v)) +} + +// CreatedByHasPrefix applies the HasPrefix predicate on the "created_by" field. +func CreatedByHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldCreatedBy, v)) +} + +// CreatedByHasSuffix applies the HasSuffix predicate on the "created_by" field. +func CreatedByHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldCreatedBy, v)) +} + +// CreatedByIsNil applies the IsNil predicate on the "created_by" field. +func CreatedByIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldCreatedBy)) +} + +// CreatedByNotNil applies the NotNil predicate on the "created_by" field. +func CreatedByNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldCreatedBy)) +} + +// CreatedByEqualFold applies the EqualFold predicate on the "created_by" field. +func CreatedByEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldCreatedBy, v)) +} + +// CreatedByContainsFold applies the ContainsFold predicate on the "created_by" field. +func CreatedByContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldCreatedBy, v)) +} + +// UpdatedByEQ applies the EQ predicate on the "updated_by" field. +func UpdatedByEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldUpdatedBy, v)) +} + +// UpdatedByNEQ applies the NEQ predicate on the "updated_by" field. +func UpdatedByNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldUpdatedBy, v)) +} + +// UpdatedByIn applies the In predicate on the "updated_by" field. +func UpdatedByIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldUpdatedBy, vs...)) +} + +// UpdatedByNotIn applies the NotIn predicate on the "updated_by" field. +func UpdatedByNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldUpdatedBy, vs...)) +} + +// UpdatedByGT applies the GT predicate on the "updated_by" field. +func UpdatedByGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldUpdatedBy, v)) +} + +// UpdatedByGTE applies the GTE predicate on the "updated_by" field. +func UpdatedByGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldUpdatedBy, v)) +} + +// UpdatedByLT applies the LT predicate on the "updated_by" field. +func UpdatedByLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldUpdatedBy, v)) +} + +// UpdatedByLTE applies the LTE predicate on the "updated_by" field. +func UpdatedByLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldUpdatedBy, v)) +} + +// UpdatedByContains applies the Contains predicate on the "updated_by" field. +func UpdatedByContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldUpdatedBy, v)) +} + +// UpdatedByHasPrefix applies the HasPrefix predicate on the "updated_by" field. +func UpdatedByHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldUpdatedBy, v)) +} + +// UpdatedByHasSuffix applies the HasSuffix predicate on the "updated_by" field. +func UpdatedByHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldUpdatedBy, v)) +} + +// UpdatedByIsNil applies the IsNil predicate on the "updated_by" field. +func UpdatedByIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldUpdatedBy)) +} + +// UpdatedByNotNil applies the NotNil predicate on the "updated_by" field. +func UpdatedByNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldUpdatedBy)) +} + +// UpdatedByEqualFold applies the EqualFold predicate on the "updated_by" field. +func UpdatedByEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldUpdatedBy, v)) +} + +// UpdatedByContainsFold applies the ContainsFold predicate on the "updated_by" field. +func UpdatedByContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldUpdatedBy, v)) +} + +// MappingIDEQ applies the EQ predicate on the "mapping_id" field. +func MappingIDEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldMappingID, v)) +} + +// MappingIDNEQ applies the NEQ predicate on the "mapping_id" field. +func MappingIDNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldMappingID, v)) +} + +// MappingIDIn applies the In predicate on the "mapping_id" field. +func MappingIDIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldMappingID, vs...)) +} + +// MappingIDNotIn applies the NotIn predicate on the "mapping_id" field. +func MappingIDNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldMappingID, vs...)) +} + +// MappingIDGT applies the GT predicate on the "mapping_id" field. +func MappingIDGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldMappingID, v)) +} + +// MappingIDGTE applies the GTE predicate on the "mapping_id" field. +func MappingIDGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldMappingID, v)) +} + +// MappingIDLT applies the LT predicate on the "mapping_id" field. +func MappingIDLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldMappingID, v)) +} + +// MappingIDLTE applies the LTE predicate on the "mapping_id" field. +func MappingIDLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldMappingID, v)) +} + +// MappingIDContains applies the Contains predicate on the "mapping_id" field. +func MappingIDContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldMappingID, v)) +} + +// MappingIDHasPrefix applies the HasPrefix predicate on the "mapping_id" field. +func MappingIDHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldMappingID, v)) +} + +// MappingIDHasSuffix applies the HasSuffix predicate on the "mapping_id" field. +func MappingIDHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldMappingID, v)) +} + +// MappingIDEqualFold applies the EqualFold predicate on the "mapping_id" field. +func MappingIDEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldMappingID, v)) +} + +// MappingIDContainsFold applies the ContainsFold predicate on the "mapping_id" field. +func MappingIDContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldMappingID, v)) +} + +// TagsIsNil applies the IsNil predicate on the "tags" field. +func TagsIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldTags)) +} + +// TagsNotNil applies the NotNil predicate on the "tags" field. +func TagsNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldTags)) +} + +// DeletedAtEQ applies the EQ predicate on the "deleted_at" field. +func DeletedAtEQ(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldDeletedAt, v)) +} + +// DeletedAtNEQ applies the NEQ predicate on the "deleted_at" field. +func DeletedAtNEQ(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldDeletedAt, v)) +} + +// DeletedAtIn applies the In predicate on the "deleted_at" field. +func DeletedAtIn(vs ...time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldDeletedAt, vs...)) +} + +// DeletedAtNotIn applies the NotIn predicate on the "deleted_at" field. +func DeletedAtNotIn(vs ...time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldDeletedAt, vs...)) +} + +// DeletedAtGT applies the GT predicate on the "deleted_at" field. +func DeletedAtGT(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldDeletedAt, v)) +} + +// DeletedAtGTE applies the GTE predicate on the "deleted_at" field. +func DeletedAtGTE(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldDeletedAt, v)) +} + +// DeletedAtLT applies the LT predicate on the "deleted_at" field. +func DeletedAtLT(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldDeletedAt, v)) +} + +// DeletedAtLTE applies the LTE predicate on the "deleted_at" field. +func DeletedAtLTE(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldDeletedAt, v)) +} + +// DeletedAtIsNil applies the IsNil predicate on the "deleted_at" field. +func DeletedAtIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldDeletedAt)) +} + +// DeletedAtNotNil applies the NotNil predicate on the "deleted_at" field. +func DeletedAtNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldDeletedAt)) +} + +// DeletedByEQ applies the EQ predicate on the "deleted_by" field. +func DeletedByEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldDeletedBy, v)) +} + +// DeletedByNEQ applies the NEQ predicate on the "deleted_by" field. +func DeletedByNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldDeletedBy, v)) +} + +// DeletedByIn applies the In predicate on the "deleted_by" field. +func DeletedByIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldDeletedBy, vs...)) +} + +// DeletedByNotIn applies the NotIn predicate on the "deleted_by" field. +func DeletedByNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldDeletedBy, vs...)) +} + +// DeletedByGT applies the GT predicate on the "deleted_by" field. +func DeletedByGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldDeletedBy, v)) +} + +// DeletedByGTE applies the GTE predicate on the "deleted_by" field. +func DeletedByGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldDeletedBy, v)) +} + +// DeletedByLT applies the LT predicate on the "deleted_by" field. +func DeletedByLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldDeletedBy, v)) +} + +// DeletedByLTE applies the LTE predicate on the "deleted_by" field. +func DeletedByLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldDeletedBy, v)) +} + +// DeletedByContains applies the Contains predicate on the "deleted_by" field. +func DeletedByContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldDeletedBy, v)) +} + +// DeletedByHasPrefix applies the HasPrefix predicate on the "deleted_by" field. +func DeletedByHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldDeletedBy, v)) +} + +// DeletedByHasSuffix applies the HasSuffix predicate on the "deleted_by" field. +func DeletedByHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldDeletedBy, v)) +} + +// DeletedByIsNil applies the IsNil predicate on the "deleted_by" field. +func DeletedByIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldDeletedBy)) +} + +// DeletedByNotNil applies the NotNil predicate on the "deleted_by" field. +func DeletedByNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldDeletedBy)) +} + +// DeletedByEqualFold applies the EqualFold predicate on the "deleted_by" field. +func DeletedByEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldDeletedBy, v)) +} + +// DeletedByContainsFold applies the ContainsFold predicate on the "deleted_by" field. +func DeletedByContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldDeletedBy, v)) +} + +// OwnerIDEQ applies the EQ predicate on the "owner_id" field. +func OwnerIDEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldOwnerID, v)) +} + +// OwnerIDNEQ applies the NEQ predicate on the "owner_id" field. +func OwnerIDNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldOwnerID, v)) +} + +// OwnerIDIn applies the In predicate on the "owner_id" field. +func OwnerIDIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldOwnerID, vs...)) +} + +// OwnerIDNotIn applies the NotIn predicate on the "owner_id" field. +func OwnerIDNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldOwnerID, vs...)) +} + +// OwnerIDGT applies the GT predicate on the "owner_id" field. +func OwnerIDGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldOwnerID, v)) +} + +// OwnerIDGTE applies the GTE predicate on the "owner_id" field. +func OwnerIDGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldOwnerID, v)) +} + +// OwnerIDLT applies the LT predicate on the "owner_id" field. +func OwnerIDLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldOwnerID, v)) +} + +// OwnerIDLTE applies the LTE predicate on the "owner_id" field. +func OwnerIDLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldOwnerID, v)) +} + +// OwnerIDContains applies the Contains predicate on the "owner_id" field. +func OwnerIDContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldOwnerID, v)) +} + +// OwnerIDHasPrefix applies the HasPrefix predicate on the "owner_id" field. +func OwnerIDHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldOwnerID, v)) +} + +// OwnerIDHasSuffix applies the HasSuffix predicate on the "owner_id" field. +func OwnerIDHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldOwnerID, v)) +} + +// OwnerIDIsNil applies the IsNil predicate on the "owner_id" field. +func OwnerIDIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldOwnerID)) +} + +// OwnerIDNotNil applies the NotNil predicate on the "owner_id" field. +func OwnerIDNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldOwnerID)) +} + +// OwnerIDEqualFold applies the EqualFold predicate on the "owner_id" field. +func OwnerIDEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldOwnerID, v)) +} + +// OwnerIDContainsFold applies the ContainsFold predicate on the "owner_id" field. +func OwnerIDContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldOwnerID, v)) +} + +// StripeSubscriptionIDEQ applies the EQ predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDNEQ applies the NEQ predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDIn applies the In predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldStripeSubscriptionID, vs...)) +} + +// StripeSubscriptionIDNotIn applies the NotIn predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldStripeSubscriptionID, vs...)) +} + +// StripeSubscriptionIDGT applies the GT predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDGTE applies the GTE predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDLT applies the LT predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDLTE applies the LTE predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDContains applies the Contains predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDHasPrefix applies the HasPrefix predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDHasSuffix applies the HasSuffix predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDIsNil applies the IsNil predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldStripeSubscriptionID)) +} + +// StripeSubscriptionIDNotNil applies the NotNil predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldStripeSubscriptionID)) +} + +// StripeSubscriptionIDEqualFold applies the EqualFold predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDContainsFold applies the ContainsFold predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldStripeSubscriptionID, v)) +} + +// ProductTierEQ applies the EQ predicate on the "product_tier" field. +func ProductTierEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldProductTier, v)) +} + +// ProductTierNEQ applies the NEQ predicate on the "product_tier" field. +func ProductTierNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldProductTier, v)) +} + +// ProductTierIn applies the In predicate on the "product_tier" field. +func ProductTierIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldProductTier, vs...)) +} + +// ProductTierNotIn applies the NotIn predicate on the "product_tier" field. +func ProductTierNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldProductTier, vs...)) +} + +// ProductTierGT applies the GT predicate on the "product_tier" field. +func ProductTierGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldProductTier, v)) +} + +// ProductTierGTE applies the GTE predicate on the "product_tier" field. +func ProductTierGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldProductTier, v)) +} + +// ProductTierLT applies the LT predicate on the "product_tier" field. +func ProductTierLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldProductTier, v)) +} + +// ProductTierLTE applies the LTE predicate on the "product_tier" field. +func ProductTierLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldProductTier, v)) +} + +// ProductTierContains applies the Contains predicate on the "product_tier" field. +func ProductTierContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldProductTier, v)) +} + +// ProductTierHasPrefix applies the HasPrefix predicate on the "product_tier" field. +func ProductTierHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldProductTier, v)) +} + +// ProductTierHasSuffix applies the HasSuffix predicate on the "product_tier" field. +func ProductTierHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldProductTier, v)) +} + +// ProductTierIsNil applies the IsNil predicate on the "product_tier" field. +func ProductTierIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldProductTier)) +} + +// ProductTierNotNil applies the NotNil predicate on the "product_tier" field. +func ProductTierNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldProductTier)) +} + +// ProductTierEqualFold applies the EqualFold predicate on the "product_tier" field. +func ProductTierEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldProductTier, v)) +} + +// ProductTierContainsFold applies the ContainsFold predicate on the "product_tier" field. +func ProductTierContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldProductTier, v)) +} + +// StripeProductTierIDEQ applies the EQ predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDNEQ applies the NEQ predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDIn applies the In predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldStripeProductTierID, vs...)) +} + +// StripeProductTierIDNotIn applies the NotIn predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldStripeProductTierID, vs...)) +} + +// StripeProductTierIDGT applies the GT predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDGTE applies the GTE predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDLT applies the LT predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDLTE applies the LTE predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDContains applies the Contains predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDHasPrefix applies the HasPrefix predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDHasSuffix applies the HasSuffix predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDIsNil applies the IsNil predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldStripeProductTierID)) +} + +// StripeProductTierIDNotNil applies the NotNil predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldStripeProductTierID)) +} + +// StripeProductTierIDEqualFold applies the EqualFold predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDContainsFold applies the ContainsFold predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldStripeProductTierID, v)) +} + +// StripeSubscriptionStatusEQ applies the EQ predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusNEQ applies the NEQ predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusIn applies the In predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldStripeSubscriptionStatus, vs...)) +} + +// StripeSubscriptionStatusNotIn applies the NotIn predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldStripeSubscriptionStatus, vs...)) +} + +// StripeSubscriptionStatusGT applies the GT predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusGTE applies the GTE predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusLT applies the LT predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusLTE applies the LTE predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusContains applies the Contains predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusHasPrefix applies the HasPrefix predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusHasSuffix applies the HasSuffix predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusIsNil applies the IsNil predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldStripeSubscriptionStatus)) +} + +// StripeSubscriptionStatusNotNil applies the NotNil predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldStripeSubscriptionStatus)) +} + +// StripeSubscriptionStatusEqualFold applies the EqualFold predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusContainsFold applies the ContainsFold predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldStripeSubscriptionStatus, v)) +} + +// ActiveEQ applies the EQ predicate on the "active" field. +func ActiveEQ(v bool) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldActive, v)) +} + +// ActiveNEQ applies the NEQ predicate on the "active" field. +func ActiveNEQ(v bool) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldActive, v)) +} + +// StripeCustomerIDEQ applies the EQ predicate on the "stripe_customer_id" field. +func StripeCustomerIDEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDNEQ applies the NEQ predicate on the "stripe_customer_id" field. +func StripeCustomerIDNEQ(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDIn applies the In predicate on the "stripe_customer_id" field. +func StripeCustomerIDIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldStripeCustomerID, vs...)) +} + +// StripeCustomerIDNotIn applies the NotIn predicate on the "stripe_customer_id" field. +func StripeCustomerIDNotIn(vs ...string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldStripeCustomerID, vs...)) +} + +// StripeCustomerIDGT applies the GT predicate on the "stripe_customer_id" field. +func StripeCustomerIDGT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDGTE applies the GTE predicate on the "stripe_customer_id" field. +func StripeCustomerIDGTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDLT applies the LT predicate on the "stripe_customer_id" field. +func StripeCustomerIDLT(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDLTE applies the LTE predicate on the "stripe_customer_id" field. +func StripeCustomerIDLTE(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDContains applies the Contains predicate on the "stripe_customer_id" field. +func StripeCustomerIDContains(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContains(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDHasPrefix applies the HasPrefix predicate on the "stripe_customer_id" field. +func StripeCustomerIDHasPrefix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasPrefix(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDHasSuffix applies the HasSuffix predicate on the "stripe_customer_id" field. +func StripeCustomerIDHasSuffix(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldHasSuffix(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDIsNil applies the IsNil predicate on the "stripe_customer_id" field. +func StripeCustomerIDIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldStripeCustomerID)) +} + +// StripeCustomerIDNotNil applies the NotNil predicate on the "stripe_customer_id" field. +func StripeCustomerIDNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldStripeCustomerID)) +} + +// StripeCustomerIDEqualFold applies the EqualFold predicate on the "stripe_customer_id" field. +func StripeCustomerIDEqualFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEqualFold(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDContainsFold applies the ContainsFold predicate on the "stripe_customer_id" field. +func StripeCustomerIDContainsFold(v string) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldContainsFold(FieldStripeCustomerID, v)) +} + +// ExpiresAtEQ applies the EQ predicate on the "expires_at" field. +func ExpiresAtEQ(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldEQ(FieldExpiresAt, v)) +} + +// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field. +func ExpiresAtNEQ(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNEQ(FieldExpiresAt, v)) +} + +// ExpiresAtIn applies the In predicate on the "expires_at" field. +func ExpiresAtIn(vs ...time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIn(FieldExpiresAt, vs...)) +} + +// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field. +func ExpiresAtNotIn(vs ...time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotIn(FieldExpiresAt, vs...)) +} + +// ExpiresAtGT applies the GT predicate on the "expires_at" field. +func ExpiresAtGT(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGT(FieldExpiresAt, v)) +} + +// ExpiresAtGTE applies the GTE predicate on the "expires_at" field. +func ExpiresAtGTE(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldGTE(FieldExpiresAt, v)) +} + +// ExpiresAtLT applies the LT predicate on the "expires_at" field. +func ExpiresAtLT(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLT(FieldExpiresAt, v)) +} + +// ExpiresAtLTE applies the LTE predicate on the "expires_at" field. +func ExpiresAtLTE(v time.Time) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldLTE(FieldExpiresAt, v)) +} + +// ExpiresAtIsNil applies the IsNil predicate on the "expires_at" field. +func ExpiresAtIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldExpiresAt)) +} + +// ExpiresAtNotNil applies the NotNil predicate on the "expires_at" field. +func ExpiresAtNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldExpiresAt)) +} + +// FeaturesIsNil applies the IsNil predicate on the "features" field. +func FeaturesIsNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldIsNull(FieldFeatures)) +} + +// FeaturesNotNil applies the NotNil predicate on the "features" field. +func FeaturesNotNil() predicate.OrgSubscription { + return predicate.OrgSubscription(sql.FieldNotNull(FieldFeatures)) +} + +// HasOwner applies the HasEdge predicate on the "owner" edge. +func HasOwner() predicate.OrgSubscription { + return predicate.OrgSubscription(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, OwnerTable, OwnerColumn), + ) + schemaConfig := internal.SchemaConfigFromContext(s.Context()) + step.To.Schema = schemaConfig.Organization + step.Edge.Schema = schemaConfig.OrgSubscription + sqlgraph.HasNeighbors(s, step) + }) +} + +// HasOwnerWith applies the HasEdge predicate on the "owner" edge with a given conditions (other predicates). +func HasOwnerWith(preds ...predicate.Organization) predicate.OrgSubscription { + return predicate.OrgSubscription(func(s *sql.Selector) { + step := newOwnerStep() + schemaConfig := internal.SchemaConfigFromContext(s.Context()) + step.To.Schema = schemaConfig.Organization + step.Edge.Schema = schemaConfig.OrgSubscription + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// And groups predicates with the AND operator between them. +func And(predicates ...predicate.OrgSubscription) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.AndPredicates(predicates...)) +} + +// Or groups predicates with the OR operator between them. +func Or(predicates ...predicate.OrgSubscription) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.OrPredicates(predicates...)) +} + +// Not applies the not operator on the given predicate. +func Not(p predicate.OrgSubscription) predicate.OrgSubscription { + return predicate.OrgSubscription(sql.NotPredicates(p)) +} diff --git a/internal/ent/generated/orgsubscription_create.go b/internal/ent/generated/orgsubscription_create.go new file mode 100644 index 00000000..3f07c0a6 --- /dev/null +++ b/internal/ent/generated/orgsubscription_create.go @@ -0,0 +1,557 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/theopenlane/core/internal/ent/generated/organization" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" +) + +// OrgSubscriptionCreate is the builder for creating a OrgSubscription entity. +type OrgSubscriptionCreate struct { + config + mutation *OrgSubscriptionMutation + hooks []Hook +} + +// SetCreatedAt sets the "created_at" field. +func (osc *OrgSubscriptionCreate) SetCreatedAt(t time.Time) *OrgSubscriptionCreate { + osc.mutation.SetCreatedAt(t) + return osc +} + +// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableCreatedAt(t *time.Time) *OrgSubscriptionCreate { + if t != nil { + osc.SetCreatedAt(*t) + } + return osc +} + +// SetUpdatedAt sets the "updated_at" field. +func (osc *OrgSubscriptionCreate) SetUpdatedAt(t time.Time) *OrgSubscriptionCreate { + osc.mutation.SetUpdatedAt(t) + return osc +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableUpdatedAt(t *time.Time) *OrgSubscriptionCreate { + if t != nil { + osc.SetUpdatedAt(*t) + } + return osc +} + +// SetCreatedBy sets the "created_by" field. +func (osc *OrgSubscriptionCreate) SetCreatedBy(s string) *OrgSubscriptionCreate { + osc.mutation.SetCreatedBy(s) + return osc +} + +// SetNillableCreatedBy sets the "created_by" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableCreatedBy(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetCreatedBy(*s) + } + return osc +} + +// SetUpdatedBy sets the "updated_by" field. +func (osc *OrgSubscriptionCreate) SetUpdatedBy(s string) *OrgSubscriptionCreate { + osc.mutation.SetUpdatedBy(s) + return osc +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableUpdatedBy(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetUpdatedBy(*s) + } + return osc +} + +// SetMappingID sets the "mapping_id" field. +func (osc *OrgSubscriptionCreate) SetMappingID(s string) *OrgSubscriptionCreate { + osc.mutation.SetMappingID(s) + return osc +} + +// SetNillableMappingID sets the "mapping_id" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableMappingID(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetMappingID(*s) + } + return osc +} + +// SetTags sets the "tags" field. +func (osc *OrgSubscriptionCreate) SetTags(s []string) *OrgSubscriptionCreate { + osc.mutation.SetTags(s) + return osc +} + +// SetDeletedAt sets the "deleted_at" field. +func (osc *OrgSubscriptionCreate) SetDeletedAt(t time.Time) *OrgSubscriptionCreate { + osc.mutation.SetDeletedAt(t) + return osc +} + +// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableDeletedAt(t *time.Time) *OrgSubscriptionCreate { + if t != nil { + osc.SetDeletedAt(*t) + } + return osc +} + +// SetDeletedBy sets the "deleted_by" field. +func (osc *OrgSubscriptionCreate) SetDeletedBy(s string) *OrgSubscriptionCreate { + osc.mutation.SetDeletedBy(s) + return osc +} + +// SetNillableDeletedBy sets the "deleted_by" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableDeletedBy(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetDeletedBy(*s) + } + return osc +} + +// SetOwnerID sets the "owner_id" field. +func (osc *OrgSubscriptionCreate) SetOwnerID(s string) *OrgSubscriptionCreate { + osc.mutation.SetOwnerID(s) + return osc +} + +// SetNillableOwnerID sets the "owner_id" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableOwnerID(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetOwnerID(*s) + } + return osc +} + +// SetStripeSubscriptionID sets the "stripe_subscription_id" field. +func (osc *OrgSubscriptionCreate) SetStripeSubscriptionID(s string) *OrgSubscriptionCreate { + osc.mutation.SetStripeSubscriptionID(s) + return osc +} + +// SetNillableStripeSubscriptionID sets the "stripe_subscription_id" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableStripeSubscriptionID(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetStripeSubscriptionID(*s) + } + return osc +} + +// SetProductTier sets the "product_tier" field. +func (osc *OrgSubscriptionCreate) SetProductTier(s string) *OrgSubscriptionCreate { + osc.mutation.SetProductTier(s) + return osc +} + +// SetNillableProductTier sets the "product_tier" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableProductTier(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetProductTier(*s) + } + return osc +} + +// SetStripeProductTierID sets the "stripe_product_tier_id" field. +func (osc *OrgSubscriptionCreate) SetStripeProductTierID(s string) *OrgSubscriptionCreate { + osc.mutation.SetStripeProductTierID(s) + return osc +} + +// SetNillableStripeProductTierID sets the "stripe_product_tier_id" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableStripeProductTierID(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetStripeProductTierID(*s) + } + return osc +} + +// SetStripeSubscriptionStatus sets the "stripe_subscription_status" field. +func (osc *OrgSubscriptionCreate) SetStripeSubscriptionStatus(s string) *OrgSubscriptionCreate { + osc.mutation.SetStripeSubscriptionStatus(s) + return osc +} + +// SetNillableStripeSubscriptionStatus sets the "stripe_subscription_status" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableStripeSubscriptionStatus(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetStripeSubscriptionStatus(*s) + } + return osc +} + +// SetActive sets the "active" field. +func (osc *OrgSubscriptionCreate) SetActive(b bool) *OrgSubscriptionCreate { + osc.mutation.SetActive(b) + return osc +} + +// SetNillableActive sets the "active" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableActive(b *bool) *OrgSubscriptionCreate { + if b != nil { + osc.SetActive(*b) + } + return osc +} + +// SetStripeCustomerID sets the "stripe_customer_id" field. +func (osc *OrgSubscriptionCreate) SetStripeCustomerID(s string) *OrgSubscriptionCreate { + osc.mutation.SetStripeCustomerID(s) + return osc +} + +// SetNillableStripeCustomerID sets the "stripe_customer_id" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableStripeCustomerID(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetStripeCustomerID(*s) + } + return osc +} + +// SetExpiresAt sets the "expires_at" field. +func (osc *OrgSubscriptionCreate) SetExpiresAt(t time.Time) *OrgSubscriptionCreate { + osc.mutation.SetExpiresAt(t) + return osc +} + +// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableExpiresAt(t *time.Time) *OrgSubscriptionCreate { + if t != nil { + osc.SetExpiresAt(*t) + } + return osc +} + +// SetFeatures sets the "features" field. +func (osc *OrgSubscriptionCreate) SetFeatures(s []string) *OrgSubscriptionCreate { + osc.mutation.SetFeatures(s) + return osc +} + +// SetID sets the "id" field. +func (osc *OrgSubscriptionCreate) SetID(s string) *OrgSubscriptionCreate { + osc.mutation.SetID(s) + return osc +} + +// SetNillableID sets the "id" field if the given value is not nil. +func (osc *OrgSubscriptionCreate) SetNillableID(s *string) *OrgSubscriptionCreate { + if s != nil { + osc.SetID(*s) + } + return osc +} + +// SetOwner sets the "owner" edge to the Organization entity. +func (osc *OrgSubscriptionCreate) SetOwner(o *Organization) *OrgSubscriptionCreate { + return osc.SetOwnerID(o.ID) +} + +// Mutation returns the OrgSubscriptionMutation object of the builder. +func (osc *OrgSubscriptionCreate) Mutation() *OrgSubscriptionMutation { + return osc.mutation +} + +// Save creates the OrgSubscription in the database. +func (osc *OrgSubscriptionCreate) Save(ctx context.Context) (*OrgSubscription, error) { + if err := osc.defaults(); err != nil { + return nil, err + } + return withHooks(ctx, osc.sqlSave, osc.mutation, osc.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (osc *OrgSubscriptionCreate) SaveX(ctx context.Context) *OrgSubscription { + v, err := osc.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (osc *OrgSubscriptionCreate) Exec(ctx context.Context) error { + _, err := osc.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (osc *OrgSubscriptionCreate) ExecX(ctx context.Context) { + if err := osc.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (osc *OrgSubscriptionCreate) defaults() error { + if _, ok := osc.mutation.CreatedAt(); !ok { + if orgsubscription.DefaultCreatedAt == nil { + return fmt.Errorf("generated: uninitialized orgsubscription.DefaultCreatedAt (forgotten import generated/runtime?)") + } + v := orgsubscription.DefaultCreatedAt() + osc.mutation.SetCreatedAt(v) + } + if _, ok := osc.mutation.UpdatedAt(); !ok { + if orgsubscription.DefaultUpdatedAt == nil { + return fmt.Errorf("generated: uninitialized orgsubscription.DefaultUpdatedAt (forgotten import generated/runtime?)") + } + v := orgsubscription.DefaultUpdatedAt() + osc.mutation.SetUpdatedAt(v) + } + if _, ok := osc.mutation.MappingID(); !ok { + if orgsubscription.DefaultMappingID == nil { + return fmt.Errorf("generated: uninitialized orgsubscription.DefaultMappingID (forgotten import generated/runtime?)") + } + v := orgsubscription.DefaultMappingID() + osc.mutation.SetMappingID(v) + } + if _, ok := osc.mutation.Tags(); !ok { + v := orgsubscription.DefaultTags + osc.mutation.SetTags(v) + } + if _, ok := osc.mutation.Active(); !ok { + v := orgsubscription.DefaultActive + osc.mutation.SetActive(v) + } + if _, ok := osc.mutation.ID(); !ok { + if orgsubscription.DefaultID == nil { + return fmt.Errorf("generated: uninitialized orgsubscription.DefaultID (forgotten import generated/runtime?)") + } + v := orgsubscription.DefaultID() + osc.mutation.SetID(v) + } + return nil +} + +// check runs all checks and user-defined validators on the builder. +func (osc *OrgSubscriptionCreate) check() error { + if _, ok := osc.mutation.MappingID(); !ok { + return &ValidationError{Name: "mapping_id", err: errors.New(`generated: missing required field "OrgSubscription.mapping_id"`)} + } + if v, ok := osc.mutation.OwnerID(); ok { + if err := orgsubscription.OwnerIDValidator(v); err != nil { + return &ValidationError{Name: "owner_id", err: fmt.Errorf(`generated: validator failed for field "OrgSubscription.owner_id": %w`, err)} + } + } + if _, ok := osc.mutation.Active(); !ok { + return &ValidationError{Name: "active", err: errors.New(`generated: missing required field "OrgSubscription.active"`)} + } + return nil +} + +func (osc *OrgSubscriptionCreate) sqlSave(ctx context.Context) (*OrgSubscription, error) { + if err := osc.check(); err != nil { + return nil, err + } + _node, _spec := osc.createSpec() + if err := sqlgraph.CreateNode(ctx, osc.driver, _spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + if _spec.ID.Value != nil { + if id, ok := _spec.ID.Value.(string); ok { + _node.ID = id + } else { + return nil, fmt.Errorf("unexpected OrgSubscription.ID type: %T", _spec.ID.Value) + } + } + osc.mutation.id = &_node.ID + osc.mutation.done = true + return _node, nil +} + +func (osc *OrgSubscriptionCreate) createSpec() (*OrgSubscription, *sqlgraph.CreateSpec) { + var ( + _node = &OrgSubscription{config: osc.config} + _spec = sqlgraph.NewCreateSpec(orgsubscription.Table, sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString)) + ) + _spec.Schema = osc.schemaConfig.OrgSubscription + if id, ok := osc.mutation.ID(); ok { + _node.ID = id + _spec.ID.Value = id + } + if value, ok := osc.mutation.CreatedAt(); ok { + _spec.SetField(orgsubscription.FieldCreatedAt, field.TypeTime, value) + _node.CreatedAt = value + } + if value, ok := osc.mutation.UpdatedAt(); ok { + _spec.SetField(orgsubscription.FieldUpdatedAt, field.TypeTime, value) + _node.UpdatedAt = value + } + if value, ok := osc.mutation.CreatedBy(); ok { + _spec.SetField(orgsubscription.FieldCreatedBy, field.TypeString, value) + _node.CreatedBy = value + } + if value, ok := osc.mutation.UpdatedBy(); ok { + _spec.SetField(orgsubscription.FieldUpdatedBy, field.TypeString, value) + _node.UpdatedBy = value + } + if value, ok := osc.mutation.MappingID(); ok { + _spec.SetField(orgsubscription.FieldMappingID, field.TypeString, value) + _node.MappingID = value + } + if value, ok := osc.mutation.Tags(); ok { + _spec.SetField(orgsubscription.FieldTags, field.TypeJSON, value) + _node.Tags = value + } + if value, ok := osc.mutation.DeletedAt(); ok { + _spec.SetField(orgsubscription.FieldDeletedAt, field.TypeTime, value) + _node.DeletedAt = value + } + if value, ok := osc.mutation.DeletedBy(); ok { + _spec.SetField(orgsubscription.FieldDeletedBy, field.TypeString, value) + _node.DeletedBy = value + } + if value, ok := osc.mutation.StripeSubscriptionID(); ok { + _spec.SetField(orgsubscription.FieldStripeSubscriptionID, field.TypeString, value) + _node.StripeSubscriptionID = value + } + if value, ok := osc.mutation.ProductTier(); ok { + _spec.SetField(orgsubscription.FieldProductTier, field.TypeString, value) + _node.ProductTier = value + } + if value, ok := osc.mutation.StripeProductTierID(); ok { + _spec.SetField(orgsubscription.FieldStripeProductTierID, field.TypeString, value) + _node.StripeProductTierID = value + } + if value, ok := osc.mutation.StripeSubscriptionStatus(); ok { + _spec.SetField(orgsubscription.FieldStripeSubscriptionStatus, field.TypeString, value) + _node.StripeSubscriptionStatus = value + } + if value, ok := osc.mutation.Active(); ok { + _spec.SetField(orgsubscription.FieldActive, field.TypeBool, value) + _node.Active = value + } + if value, ok := osc.mutation.StripeCustomerID(); ok { + _spec.SetField(orgsubscription.FieldStripeCustomerID, field.TypeString, value) + _node.StripeCustomerID = value + } + if value, ok := osc.mutation.ExpiresAt(); ok { + _spec.SetField(orgsubscription.FieldExpiresAt, field.TypeTime, value) + _node.ExpiresAt = &value + } + if value, ok := osc.mutation.Features(); ok { + _spec.SetField(orgsubscription.FieldFeatures, field.TypeJSON, value) + _node.Features = value + } + if nodes := osc.mutation.OwnerIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: orgsubscription.OwnerTable, + Columns: []string{orgsubscription.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(organization.FieldID, field.TypeString), + }, + } + edge.Schema = osc.schemaConfig.OrgSubscription + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _node.OwnerID = nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + return _node, _spec +} + +// OrgSubscriptionCreateBulk is the builder for creating many OrgSubscription entities in bulk. +type OrgSubscriptionCreateBulk struct { + config + err error + builders []*OrgSubscriptionCreate +} + +// Save creates the OrgSubscription entities in the database. +func (oscb *OrgSubscriptionCreateBulk) Save(ctx context.Context) ([]*OrgSubscription, error) { + if oscb.err != nil { + return nil, oscb.err + } + specs := make([]*sqlgraph.CreateSpec, len(oscb.builders)) + nodes := make([]*OrgSubscription, len(oscb.builders)) + mutators := make([]Mutator, len(oscb.builders)) + for i := range oscb.builders { + func(i int, root context.Context) { + builder := oscb.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*OrgSubscriptionMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + var err error + nodes[i], specs[i] = builder.createSpec() + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, oscb.builders[i+1].mutation) + } else { + spec := &sqlgraph.BatchCreateSpec{Nodes: specs} + // Invoke the actual operation on the latest mutation in the chain. + if err = sqlgraph.BatchCreate(ctx, oscb.driver, spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + } + } + if err != nil { + return nil, err + } + mutation.id = &nodes[i].ID + mutation.done = true + return nodes[i], nil + }) + for i := len(builder.hooks) - 1; i >= 0; i-- { + mut = builder.hooks[i](mut) + } + mutators[i] = mut + }(i, ctx) + } + if len(mutators) > 0 { + if _, err := mutators[0].Mutate(ctx, oscb.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (oscb *OrgSubscriptionCreateBulk) SaveX(ctx context.Context) []*OrgSubscription { + v, err := oscb.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (oscb *OrgSubscriptionCreateBulk) Exec(ctx context.Context) error { + _, err := oscb.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (oscb *OrgSubscriptionCreateBulk) ExecX(ctx context.Context) { + if err := oscb.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/internal/ent/generated/orgsubscription_delete.go b/internal/ent/generated/orgsubscription_delete.go new file mode 100644 index 00000000..97753042 --- /dev/null +++ b/internal/ent/generated/orgsubscription_delete.go @@ -0,0 +1,92 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "context" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/theopenlane/core/internal/ent/generated/predicate" + + "github.com/theopenlane/core/internal/ent/generated/internal" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" +) + +// OrgSubscriptionDelete is the builder for deleting a OrgSubscription entity. +type OrgSubscriptionDelete struct { + config + hooks []Hook + mutation *OrgSubscriptionMutation +} + +// Where appends a list predicates to the OrgSubscriptionDelete builder. +func (osd *OrgSubscriptionDelete) Where(ps ...predicate.OrgSubscription) *OrgSubscriptionDelete { + osd.mutation.Where(ps...) + return osd +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (osd *OrgSubscriptionDelete) Exec(ctx context.Context) (int, error) { + return withHooks(ctx, osd.sqlExec, osd.mutation, osd.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (osd *OrgSubscriptionDelete) ExecX(ctx context.Context) int { + n, err := osd.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (osd *OrgSubscriptionDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(orgsubscription.Table, sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString)) + _spec.Node.Schema = osd.schemaConfig.OrgSubscription + ctx = internal.NewSchemaConfigContext(ctx, osd.schemaConfig) + if ps := osd.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, osd.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + osd.mutation.done = true + return affected, err +} + +// OrgSubscriptionDeleteOne is the builder for deleting a single OrgSubscription entity. +type OrgSubscriptionDeleteOne struct { + osd *OrgSubscriptionDelete +} + +// Where appends a list predicates to the OrgSubscriptionDelete builder. +func (osdo *OrgSubscriptionDeleteOne) Where(ps ...predicate.OrgSubscription) *OrgSubscriptionDeleteOne { + osdo.osd.mutation.Where(ps...) + return osdo +} + +// Exec executes the deletion query. +func (osdo *OrgSubscriptionDeleteOne) Exec(ctx context.Context) error { + n, err := osdo.osd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{orgsubscription.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (osdo *OrgSubscriptionDeleteOne) ExecX(ctx context.Context) { + if err := osdo.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/internal/ent/generated/orgsubscription_query.go b/internal/ent/generated/orgsubscription_query.go new file mode 100644 index 00000000..fceb6878 --- /dev/null +++ b/internal/ent/generated/orgsubscription_query.go @@ -0,0 +1,647 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "context" + "fmt" + "math" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/theopenlane/core/internal/ent/generated/organization" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/predicate" + + "github.com/theopenlane/core/internal/ent/generated/internal" +) + +// OrgSubscriptionQuery is the builder for querying OrgSubscription entities. +type OrgSubscriptionQuery struct { + config + ctx *QueryContext + order []orgsubscription.OrderOption + inters []Interceptor + predicates []predicate.OrgSubscription + withOwner *OrganizationQuery + loadTotal []func(context.Context, []*OrgSubscription) error + modifiers []func(*sql.Selector) + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Where adds a new predicate for the OrgSubscriptionQuery builder. +func (osq *OrgSubscriptionQuery) Where(ps ...predicate.OrgSubscription) *OrgSubscriptionQuery { + osq.predicates = append(osq.predicates, ps...) + return osq +} + +// Limit the number of records to be returned by this query. +func (osq *OrgSubscriptionQuery) Limit(limit int) *OrgSubscriptionQuery { + osq.ctx.Limit = &limit + return osq +} + +// Offset to start from. +func (osq *OrgSubscriptionQuery) Offset(offset int) *OrgSubscriptionQuery { + osq.ctx.Offset = &offset + return osq +} + +// Unique configures the query builder to filter duplicate records on query. +// By default, unique is set to true, and can be disabled using this method. +func (osq *OrgSubscriptionQuery) Unique(unique bool) *OrgSubscriptionQuery { + osq.ctx.Unique = &unique + return osq +} + +// Order specifies how the records should be ordered. +func (osq *OrgSubscriptionQuery) Order(o ...orgsubscription.OrderOption) *OrgSubscriptionQuery { + osq.order = append(osq.order, o...) + return osq +} + +// QueryOwner chains the current query on the "owner" edge. +func (osq *OrgSubscriptionQuery) QueryOwner() *OrganizationQuery { + query := (&OrganizationClient{config: osq.config}).Query() + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := osq.prepareQuery(ctx); err != nil { + return nil, err + } + selector := osq.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(orgsubscription.Table, orgsubscription.FieldID, selector), + sqlgraph.To(organization.Table, organization.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, orgsubscription.OwnerTable, orgsubscription.OwnerColumn), + ) + schemaConfig := osq.schemaConfig + step.To.Schema = schemaConfig.Organization + step.Edge.Schema = schemaConfig.OrgSubscription + fromU = sqlgraph.SetNeighbors(osq.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// First returns the first OrgSubscription entity from the query. +// Returns a *NotFoundError when no OrgSubscription was found. +func (osq *OrgSubscriptionQuery) First(ctx context.Context) (*OrgSubscription, error) { + nodes, err := osq.Limit(1).All(setContextOp(ctx, osq.ctx, ent.OpQueryFirst)) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{orgsubscription.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (osq *OrgSubscriptionQuery) FirstX(ctx context.Context) *OrgSubscription { + node, err := osq.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first OrgSubscription ID from the query. +// Returns a *NotFoundError when no OrgSubscription ID was found. +func (osq *OrgSubscriptionQuery) FirstID(ctx context.Context) (id string, err error) { + var ids []string + if ids, err = osq.Limit(1).IDs(setContextOp(ctx, osq.ctx, ent.OpQueryFirstID)); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{orgsubscription.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (osq *OrgSubscriptionQuery) FirstIDX(ctx context.Context) string { + id, err := osq.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single OrgSubscription entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one OrgSubscription entity is found. +// Returns a *NotFoundError when no OrgSubscription entities are found. +func (osq *OrgSubscriptionQuery) Only(ctx context.Context) (*OrgSubscription, error) { + nodes, err := osq.Limit(2).All(setContextOp(ctx, osq.ctx, ent.OpQueryOnly)) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{orgsubscription.Label} + default: + return nil, &NotSingularError{orgsubscription.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (osq *OrgSubscriptionQuery) OnlyX(ctx context.Context) *OrgSubscription { + node, err := osq.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only OrgSubscription ID in the query. +// Returns a *NotSingularError when more than one OrgSubscription ID is found. +// Returns a *NotFoundError when no entities are found. +func (osq *OrgSubscriptionQuery) OnlyID(ctx context.Context) (id string, err error) { + var ids []string + if ids, err = osq.Limit(2).IDs(setContextOp(ctx, osq.ctx, ent.OpQueryOnlyID)); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{orgsubscription.Label} + default: + err = &NotSingularError{orgsubscription.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (osq *OrgSubscriptionQuery) OnlyIDX(ctx context.Context) string { + id, err := osq.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of OrgSubscriptions. +func (osq *OrgSubscriptionQuery) All(ctx context.Context) ([]*OrgSubscription, error) { + ctx = setContextOp(ctx, osq.ctx, ent.OpQueryAll) + if err := osq.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*OrgSubscription, *OrgSubscriptionQuery]() + return withInterceptors[[]*OrgSubscription](ctx, osq, qr, osq.inters) +} + +// AllX is like All, but panics if an error occurs. +func (osq *OrgSubscriptionQuery) AllX(ctx context.Context) []*OrgSubscription { + nodes, err := osq.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of OrgSubscription IDs. +func (osq *OrgSubscriptionQuery) IDs(ctx context.Context) (ids []string, err error) { + if osq.ctx.Unique == nil && osq.path != nil { + osq.Unique(true) + } + ctx = setContextOp(ctx, osq.ctx, ent.OpQueryIDs) + if err = osq.Select(orgsubscription.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (osq *OrgSubscriptionQuery) IDsX(ctx context.Context) []string { + ids, err := osq.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (osq *OrgSubscriptionQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, osq.ctx, ent.OpQueryCount) + if err := osq.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, osq, querierCount[*OrgSubscriptionQuery](), osq.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (osq *OrgSubscriptionQuery) CountX(ctx context.Context) int { + count, err := osq.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (osq *OrgSubscriptionQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, osq.ctx, ent.OpQueryExist) + switch _, err := osq.FirstID(ctx); { + case IsNotFound(err): + return false, nil + case err != nil: + return false, fmt.Errorf("generated: check existence: %w", err) + default: + return true, nil + } +} + +// ExistX is like Exist, but panics if an error occurs. +func (osq *OrgSubscriptionQuery) ExistX(ctx context.Context) bool { + exist, err := osq.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the OrgSubscriptionQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (osq *OrgSubscriptionQuery) Clone() *OrgSubscriptionQuery { + if osq == nil { + return nil + } + return &OrgSubscriptionQuery{ + config: osq.config, + ctx: osq.ctx.Clone(), + order: append([]orgsubscription.OrderOption{}, osq.order...), + inters: append([]Interceptor{}, osq.inters...), + predicates: append([]predicate.OrgSubscription{}, osq.predicates...), + withOwner: osq.withOwner.Clone(), + // clone intermediate query. + sql: osq.sql.Clone(), + path: osq.path, + modifiers: append([]func(*sql.Selector){}, osq.modifiers...), + } +} + +// WithOwner tells the query-builder to eager-load the nodes that are connected to +// the "owner" edge. The optional arguments are used to configure the query builder of the edge. +func (osq *OrgSubscriptionQuery) WithOwner(opts ...func(*OrganizationQuery)) *OrgSubscriptionQuery { + query := (&OrganizationClient{config: osq.config}).Query() + for _, opt := range opts { + opt(query) + } + osq.withOwner = query + return osq +} + +// GroupBy is used to group vertices by one or more fields/columns. +// It is often used with aggregate functions, like: count, max, mean, min, sum. +// +// Example: +// +// var v []struct { +// CreatedAt time.Time `json:"created_at,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.OrgSubscription.Query(). +// GroupBy(orgsubscription.FieldCreatedAt). +// Aggregate(generated.Count()). +// Scan(ctx, &v) +func (osq *OrgSubscriptionQuery) GroupBy(field string, fields ...string) *OrgSubscriptionGroupBy { + osq.ctx.Fields = append([]string{field}, fields...) + grbuild := &OrgSubscriptionGroupBy{build: osq} + grbuild.flds = &osq.ctx.Fields + grbuild.label = orgsubscription.Label + grbuild.scan = grbuild.Scan + return grbuild +} + +// Select allows the selection one or more fields/columns for the given query, +// instead of selecting all fields in the entity. +// +// Example: +// +// var v []struct { +// CreatedAt time.Time `json:"created_at,omitempty"` +// } +// +// client.OrgSubscription.Query(). +// Select(orgsubscription.FieldCreatedAt). +// Scan(ctx, &v) +func (osq *OrgSubscriptionQuery) Select(fields ...string) *OrgSubscriptionSelect { + osq.ctx.Fields = append(osq.ctx.Fields, fields...) + sbuild := &OrgSubscriptionSelect{OrgSubscriptionQuery: osq} + sbuild.label = orgsubscription.Label + sbuild.flds, sbuild.scan = &osq.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a OrgSubscriptionSelect configured with the given aggregations. +func (osq *OrgSubscriptionQuery) Aggregate(fns ...AggregateFunc) *OrgSubscriptionSelect { + return osq.Select().Aggregate(fns...) +} + +func (osq *OrgSubscriptionQuery) prepareQuery(ctx context.Context) error { + for _, inter := range osq.inters { + if inter == nil { + return fmt.Errorf("generated: uninitialized interceptor (forgotten import generated/runtime?)") + } + if trv, ok := inter.(Traverser); ok { + if err := trv.Traverse(ctx, osq); err != nil { + return err + } + } + } + for _, f := range osq.ctx.Fields { + if !orgsubscription.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("generated: invalid field %q for query", f)} + } + } + if osq.path != nil { + prev, err := osq.path(ctx) + if err != nil { + return err + } + osq.sql = prev + } + return nil +} + +func (osq *OrgSubscriptionQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*OrgSubscription, error) { + var ( + nodes = []*OrgSubscription{} + _spec = osq.querySpec() + loadedTypes = [1]bool{ + osq.withOwner != nil, + } + ) + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*OrgSubscription).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &OrgSubscription{config: osq.config} + nodes = append(nodes, node) + node.Edges.loadedTypes = loadedTypes + return node.assignValues(columns, values) + } + _spec.Node.Schema = osq.schemaConfig.OrgSubscription + ctx = internal.NewSchemaConfigContext(ctx, osq.schemaConfig) + if len(osq.modifiers) > 0 { + _spec.Modifiers = osq.modifiers + } + for i := range hooks { + hooks[i](ctx, _spec) + } + if err := sqlgraph.QueryNodes(ctx, osq.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + if query := osq.withOwner; query != nil { + if err := osq.loadOwner(ctx, query, nodes, nil, + func(n *OrgSubscription, e *Organization) { n.Edges.Owner = e }); err != nil { + return nil, err + } + } + for i := range osq.loadTotal { + if err := osq.loadTotal[i](ctx, nodes); err != nil { + return nil, err + } + } + return nodes, nil +} + +func (osq *OrgSubscriptionQuery) loadOwner(ctx context.Context, query *OrganizationQuery, nodes []*OrgSubscription, init func(*OrgSubscription), assign func(*OrgSubscription, *Organization)) error { + ids := make([]string, 0, len(nodes)) + nodeids := make(map[string][]*OrgSubscription) + for i := range nodes { + fk := nodes[i].OwnerID + if _, ok := nodeids[fk]; !ok { + ids = append(ids, fk) + } + nodeids[fk] = append(nodeids[fk], nodes[i]) + } + if len(ids) == 0 { + return nil + } + query.Where(organization.IDIn(ids...)) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + nodes, ok := nodeids[n.ID] + if !ok { + return fmt.Errorf(`unexpected foreign-key "owner_id" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} + +func (osq *OrgSubscriptionQuery) sqlCount(ctx context.Context) (int, error) { + _spec := osq.querySpec() + _spec.Node.Schema = osq.schemaConfig.OrgSubscription + ctx = internal.NewSchemaConfigContext(ctx, osq.schemaConfig) + if len(osq.modifiers) > 0 { + _spec.Modifiers = osq.modifiers + } + _spec.Node.Columns = osq.ctx.Fields + if len(osq.ctx.Fields) > 0 { + _spec.Unique = osq.ctx.Unique != nil && *osq.ctx.Unique + } + return sqlgraph.CountNodes(ctx, osq.driver, _spec) +} + +func (osq *OrgSubscriptionQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(orgsubscription.Table, orgsubscription.Columns, sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString)) + _spec.From = osq.sql + if unique := osq.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if osq.path != nil { + _spec.Unique = true + } + if fields := osq.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, orgsubscription.FieldID) + for i := range fields { + if fields[i] != orgsubscription.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + if osq.withOwner != nil { + _spec.Node.AddColumnOnce(orgsubscription.FieldOwnerID) + } + } + if ps := osq.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := osq.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := osq.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := osq.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (osq *OrgSubscriptionQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(osq.driver.Dialect()) + t1 := builder.Table(orgsubscription.Table) + columns := osq.ctx.Fields + if len(columns) == 0 { + columns = orgsubscription.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if osq.sql != nil { + selector = osq.sql + selector.Select(selector.Columns(columns...)...) + } + if osq.ctx.Unique != nil && *osq.ctx.Unique { + selector.Distinct() + } + t1.Schema(osq.schemaConfig.OrgSubscription) + ctx = internal.NewSchemaConfigContext(ctx, osq.schemaConfig) + selector.WithContext(ctx) + for _, m := range osq.modifiers { + m(selector) + } + for _, p := range osq.predicates { + p(selector) + } + for _, p := range osq.order { + p(selector) + } + if offset := osq.ctx.Offset; offset != nil { + // limit is mandatory for offset clause. We start + // with default value, and override it below if needed. + selector.Offset(*offset).Limit(math.MaxInt32) + } + if limit := osq.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// Modify adds a query modifier for attaching custom logic to queries. +func (osq *OrgSubscriptionQuery) Modify(modifiers ...func(s *sql.Selector)) *OrgSubscriptionSelect { + osq.modifiers = append(osq.modifiers, modifiers...) + return osq.Select() +} + +// OrgSubscriptionGroupBy is the group-by builder for OrgSubscription entities. +type OrgSubscriptionGroupBy struct { + selector + build *OrgSubscriptionQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (osgb *OrgSubscriptionGroupBy) Aggregate(fns ...AggregateFunc) *OrgSubscriptionGroupBy { + osgb.fns = append(osgb.fns, fns...) + return osgb +} + +// Scan applies the selector query and scans the result into the given value. +func (osgb *OrgSubscriptionGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, osgb.build.ctx, ent.OpQueryGroupBy) + if err := osgb.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*OrgSubscriptionQuery, *OrgSubscriptionGroupBy](ctx, osgb.build, osgb, osgb.build.inters, v) +} + +func (osgb *OrgSubscriptionGroupBy) sqlScan(ctx context.Context, root *OrgSubscriptionQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(osgb.fns)) + for _, fn := range osgb.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*osgb.flds)+len(osgb.fns)) + for _, f := range *osgb.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*osgb.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := osgb.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// OrgSubscriptionSelect is the builder for selecting fields of OrgSubscription entities. +type OrgSubscriptionSelect struct { + *OrgSubscriptionQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (oss *OrgSubscriptionSelect) Aggregate(fns ...AggregateFunc) *OrgSubscriptionSelect { + oss.fns = append(oss.fns, fns...) + return oss +} + +// Scan applies the selector query and scans the result into the given value. +func (oss *OrgSubscriptionSelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, oss.ctx, ent.OpQuerySelect) + if err := oss.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*OrgSubscriptionQuery, *OrgSubscriptionSelect](ctx, oss.OrgSubscriptionQuery, oss, oss.inters, v) +} + +func (oss *OrgSubscriptionSelect) sqlScan(ctx context.Context, root *OrgSubscriptionQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(oss.fns)) + for _, fn := range oss.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*oss.selector.flds); { + case n == 0 && len(aggregation) > 0: + selector.Select(aggregation...) + case n != 0 && len(aggregation) > 0: + selector.AppendSelect(aggregation...) + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := oss.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// Modify adds a query modifier for attaching custom logic to queries. +func (oss *OrgSubscriptionSelect) Modify(modifiers ...func(s *sql.Selector)) *OrgSubscriptionSelect { + oss.modifiers = append(oss.modifiers, modifiers...) + return oss +} diff --git a/internal/ent/generated/orgsubscription_update.go b/internal/ent/generated/orgsubscription_update.go new file mode 100644 index 00000000..f4c83308 --- /dev/null +++ b/internal/ent/generated/orgsubscription_update.go @@ -0,0 +1,1046 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/dialect/sql/sqljson" + "entgo.io/ent/schema/field" + "github.com/theopenlane/core/internal/ent/generated/organization" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/predicate" + + "github.com/theopenlane/core/internal/ent/generated/internal" +) + +// OrgSubscriptionUpdate is the builder for updating OrgSubscription entities. +type OrgSubscriptionUpdate struct { + config + hooks []Hook + mutation *OrgSubscriptionMutation + modifiers []func(*sql.UpdateBuilder) +} + +// Where appends a list predicates to the OrgSubscriptionUpdate builder. +func (osu *OrgSubscriptionUpdate) Where(ps ...predicate.OrgSubscription) *OrgSubscriptionUpdate { + osu.mutation.Where(ps...) + return osu +} + +// SetUpdatedAt sets the "updated_at" field. +func (osu *OrgSubscriptionUpdate) SetUpdatedAt(t time.Time) *OrgSubscriptionUpdate { + osu.mutation.SetUpdatedAt(t) + return osu +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (osu *OrgSubscriptionUpdate) ClearUpdatedAt() *OrgSubscriptionUpdate { + osu.mutation.ClearUpdatedAt() + return osu +} + +// SetUpdatedBy sets the "updated_by" field. +func (osu *OrgSubscriptionUpdate) SetUpdatedBy(s string) *OrgSubscriptionUpdate { + osu.mutation.SetUpdatedBy(s) + return osu +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableUpdatedBy(s *string) *OrgSubscriptionUpdate { + if s != nil { + osu.SetUpdatedBy(*s) + } + return osu +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (osu *OrgSubscriptionUpdate) ClearUpdatedBy() *OrgSubscriptionUpdate { + osu.mutation.ClearUpdatedBy() + return osu +} + +// SetTags sets the "tags" field. +func (osu *OrgSubscriptionUpdate) SetTags(s []string) *OrgSubscriptionUpdate { + osu.mutation.SetTags(s) + return osu +} + +// AppendTags appends s to the "tags" field. +func (osu *OrgSubscriptionUpdate) AppendTags(s []string) *OrgSubscriptionUpdate { + osu.mutation.AppendTags(s) + return osu +} + +// ClearTags clears the value of the "tags" field. +func (osu *OrgSubscriptionUpdate) ClearTags() *OrgSubscriptionUpdate { + osu.mutation.ClearTags() + return osu +} + +// SetDeletedAt sets the "deleted_at" field. +func (osu *OrgSubscriptionUpdate) SetDeletedAt(t time.Time) *OrgSubscriptionUpdate { + osu.mutation.SetDeletedAt(t) + return osu +} + +// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableDeletedAt(t *time.Time) *OrgSubscriptionUpdate { + if t != nil { + osu.SetDeletedAt(*t) + } + return osu +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (osu *OrgSubscriptionUpdate) ClearDeletedAt() *OrgSubscriptionUpdate { + osu.mutation.ClearDeletedAt() + return osu +} + +// SetDeletedBy sets the "deleted_by" field. +func (osu *OrgSubscriptionUpdate) SetDeletedBy(s string) *OrgSubscriptionUpdate { + osu.mutation.SetDeletedBy(s) + return osu +} + +// SetNillableDeletedBy sets the "deleted_by" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableDeletedBy(s *string) *OrgSubscriptionUpdate { + if s != nil { + osu.SetDeletedBy(*s) + } + return osu +} + +// ClearDeletedBy clears the value of the "deleted_by" field. +func (osu *OrgSubscriptionUpdate) ClearDeletedBy() *OrgSubscriptionUpdate { + osu.mutation.ClearDeletedBy() + return osu +} + +// SetOwnerID sets the "owner_id" field. +func (osu *OrgSubscriptionUpdate) SetOwnerID(s string) *OrgSubscriptionUpdate { + osu.mutation.SetOwnerID(s) + return osu +} + +// SetNillableOwnerID sets the "owner_id" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableOwnerID(s *string) *OrgSubscriptionUpdate { + if s != nil { + osu.SetOwnerID(*s) + } + return osu +} + +// ClearOwnerID clears the value of the "owner_id" field. +func (osu *OrgSubscriptionUpdate) ClearOwnerID() *OrgSubscriptionUpdate { + osu.mutation.ClearOwnerID() + return osu +} + +// SetStripeSubscriptionID sets the "stripe_subscription_id" field. +func (osu *OrgSubscriptionUpdate) SetStripeSubscriptionID(s string) *OrgSubscriptionUpdate { + osu.mutation.SetStripeSubscriptionID(s) + return osu +} + +// SetNillableStripeSubscriptionID sets the "stripe_subscription_id" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableStripeSubscriptionID(s *string) *OrgSubscriptionUpdate { + if s != nil { + osu.SetStripeSubscriptionID(*s) + } + return osu +} + +// ClearStripeSubscriptionID clears the value of the "stripe_subscription_id" field. +func (osu *OrgSubscriptionUpdate) ClearStripeSubscriptionID() *OrgSubscriptionUpdate { + osu.mutation.ClearStripeSubscriptionID() + return osu +} + +// SetProductTier sets the "product_tier" field. +func (osu *OrgSubscriptionUpdate) SetProductTier(s string) *OrgSubscriptionUpdate { + osu.mutation.SetProductTier(s) + return osu +} + +// SetNillableProductTier sets the "product_tier" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableProductTier(s *string) *OrgSubscriptionUpdate { + if s != nil { + osu.SetProductTier(*s) + } + return osu +} + +// ClearProductTier clears the value of the "product_tier" field. +func (osu *OrgSubscriptionUpdate) ClearProductTier() *OrgSubscriptionUpdate { + osu.mutation.ClearProductTier() + return osu +} + +// SetStripeProductTierID sets the "stripe_product_tier_id" field. +func (osu *OrgSubscriptionUpdate) SetStripeProductTierID(s string) *OrgSubscriptionUpdate { + osu.mutation.SetStripeProductTierID(s) + return osu +} + +// SetNillableStripeProductTierID sets the "stripe_product_tier_id" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableStripeProductTierID(s *string) *OrgSubscriptionUpdate { + if s != nil { + osu.SetStripeProductTierID(*s) + } + return osu +} + +// ClearStripeProductTierID clears the value of the "stripe_product_tier_id" field. +func (osu *OrgSubscriptionUpdate) ClearStripeProductTierID() *OrgSubscriptionUpdate { + osu.mutation.ClearStripeProductTierID() + return osu +} + +// SetStripeSubscriptionStatus sets the "stripe_subscription_status" field. +func (osu *OrgSubscriptionUpdate) SetStripeSubscriptionStatus(s string) *OrgSubscriptionUpdate { + osu.mutation.SetStripeSubscriptionStatus(s) + return osu +} + +// SetNillableStripeSubscriptionStatus sets the "stripe_subscription_status" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableStripeSubscriptionStatus(s *string) *OrgSubscriptionUpdate { + if s != nil { + osu.SetStripeSubscriptionStatus(*s) + } + return osu +} + +// ClearStripeSubscriptionStatus clears the value of the "stripe_subscription_status" field. +func (osu *OrgSubscriptionUpdate) ClearStripeSubscriptionStatus() *OrgSubscriptionUpdate { + osu.mutation.ClearStripeSubscriptionStatus() + return osu +} + +// SetActive sets the "active" field. +func (osu *OrgSubscriptionUpdate) SetActive(b bool) *OrgSubscriptionUpdate { + osu.mutation.SetActive(b) + return osu +} + +// SetNillableActive sets the "active" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableActive(b *bool) *OrgSubscriptionUpdate { + if b != nil { + osu.SetActive(*b) + } + return osu +} + +// SetStripeCustomerID sets the "stripe_customer_id" field. +func (osu *OrgSubscriptionUpdate) SetStripeCustomerID(s string) *OrgSubscriptionUpdate { + osu.mutation.SetStripeCustomerID(s) + return osu +} + +// SetNillableStripeCustomerID sets the "stripe_customer_id" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableStripeCustomerID(s *string) *OrgSubscriptionUpdate { + if s != nil { + osu.SetStripeCustomerID(*s) + } + return osu +} + +// ClearStripeCustomerID clears the value of the "stripe_customer_id" field. +func (osu *OrgSubscriptionUpdate) ClearStripeCustomerID() *OrgSubscriptionUpdate { + osu.mutation.ClearStripeCustomerID() + return osu +} + +// SetExpiresAt sets the "expires_at" field. +func (osu *OrgSubscriptionUpdate) SetExpiresAt(t time.Time) *OrgSubscriptionUpdate { + osu.mutation.SetExpiresAt(t) + return osu +} + +// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil. +func (osu *OrgSubscriptionUpdate) SetNillableExpiresAt(t *time.Time) *OrgSubscriptionUpdate { + if t != nil { + osu.SetExpiresAt(*t) + } + return osu +} + +// ClearExpiresAt clears the value of the "expires_at" field. +func (osu *OrgSubscriptionUpdate) ClearExpiresAt() *OrgSubscriptionUpdate { + osu.mutation.ClearExpiresAt() + return osu +} + +// SetFeatures sets the "features" field. +func (osu *OrgSubscriptionUpdate) SetFeatures(s []string) *OrgSubscriptionUpdate { + osu.mutation.SetFeatures(s) + return osu +} + +// AppendFeatures appends s to the "features" field. +func (osu *OrgSubscriptionUpdate) AppendFeatures(s []string) *OrgSubscriptionUpdate { + osu.mutation.AppendFeatures(s) + return osu +} + +// ClearFeatures clears the value of the "features" field. +func (osu *OrgSubscriptionUpdate) ClearFeatures() *OrgSubscriptionUpdate { + osu.mutation.ClearFeatures() + return osu +} + +// SetOwner sets the "owner" edge to the Organization entity. +func (osu *OrgSubscriptionUpdate) SetOwner(o *Organization) *OrgSubscriptionUpdate { + return osu.SetOwnerID(o.ID) +} + +// Mutation returns the OrgSubscriptionMutation object of the builder. +func (osu *OrgSubscriptionUpdate) Mutation() *OrgSubscriptionMutation { + return osu.mutation +} + +// ClearOwner clears the "owner" edge to the Organization entity. +func (osu *OrgSubscriptionUpdate) ClearOwner() *OrgSubscriptionUpdate { + osu.mutation.ClearOwner() + return osu +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (osu *OrgSubscriptionUpdate) Save(ctx context.Context) (int, error) { + if err := osu.defaults(); err != nil { + return 0, err + } + return withHooks(ctx, osu.sqlSave, osu.mutation, osu.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (osu *OrgSubscriptionUpdate) SaveX(ctx context.Context) int { + affected, err := osu.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (osu *OrgSubscriptionUpdate) Exec(ctx context.Context) error { + _, err := osu.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (osu *OrgSubscriptionUpdate) ExecX(ctx context.Context) { + if err := osu.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (osu *OrgSubscriptionUpdate) defaults() error { + if _, ok := osu.mutation.UpdatedAt(); !ok && !osu.mutation.UpdatedAtCleared() { + if orgsubscription.UpdateDefaultUpdatedAt == nil { + return fmt.Errorf("generated: uninitialized orgsubscription.UpdateDefaultUpdatedAt (forgotten import generated/runtime?)") + } + v := orgsubscription.UpdateDefaultUpdatedAt() + osu.mutation.SetUpdatedAt(v) + } + return nil +} + +// check runs all checks and user-defined validators on the builder. +func (osu *OrgSubscriptionUpdate) check() error { + if v, ok := osu.mutation.OwnerID(); ok { + if err := orgsubscription.OwnerIDValidator(v); err != nil { + return &ValidationError{Name: "owner_id", err: fmt.Errorf(`generated: validator failed for field "OrgSubscription.owner_id": %w`, err)} + } + } + return nil +} + +// Modify adds a statement modifier for attaching custom logic to the UPDATE statement. +func (osu *OrgSubscriptionUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *OrgSubscriptionUpdate { + osu.modifiers = append(osu.modifiers, modifiers...) + return osu +} + +func (osu *OrgSubscriptionUpdate) sqlSave(ctx context.Context) (n int, err error) { + if err := osu.check(); err != nil { + return n, err + } + _spec := sqlgraph.NewUpdateSpec(orgsubscription.Table, orgsubscription.Columns, sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString)) + if ps := osu.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if osu.mutation.CreatedAtCleared() { + _spec.ClearField(orgsubscription.FieldCreatedAt, field.TypeTime) + } + if value, ok := osu.mutation.UpdatedAt(); ok { + _spec.SetField(orgsubscription.FieldUpdatedAt, field.TypeTime, value) + } + if osu.mutation.UpdatedAtCleared() { + _spec.ClearField(orgsubscription.FieldUpdatedAt, field.TypeTime) + } + if osu.mutation.CreatedByCleared() { + _spec.ClearField(orgsubscription.FieldCreatedBy, field.TypeString) + } + if value, ok := osu.mutation.UpdatedBy(); ok { + _spec.SetField(orgsubscription.FieldUpdatedBy, field.TypeString, value) + } + if osu.mutation.UpdatedByCleared() { + _spec.ClearField(orgsubscription.FieldUpdatedBy, field.TypeString) + } + if value, ok := osu.mutation.Tags(); ok { + _spec.SetField(orgsubscription.FieldTags, field.TypeJSON, value) + } + if value, ok := osu.mutation.AppendedTags(); ok { + _spec.AddModifier(func(u *sql.UpdateBuilder) { + sqljson.Append(u, orgsubscription.FieldTags, value) + }) + } + if osu.mutation.TagsCleared() { + _spec.ClearField(orgsubscription.FieldTags, field.TypeJSON) + } + if value, ok := osu.mutation.DeletedAt(); ok { + _spec.SetField(orgsubscription.FieldDeletedAt, field.TypeTime, value) + } + if osu.mutation.DeletedAtCleared() { + _spec.ClearField(orgsubscription.FieldDeletedAt, field.TypeTime) + } + if value, ok := osu.mutation.DeletedBy(); ok { + _spec.SetField(orgsubscription.FieldDeletedBy, field.TypeString, value) + } + if osu.mutation.DeletedByCleared() { + _spec.ClearField(orgsubscription.FieldDeletedBy, field.TypeString) + } + if value, ok := osu.mutation.StripeSubscriptionID(); ok { + _spec.SetField(orgsubscription.FieldStripeSubscriptionID, field.TypeString, value) + } + if osu.mutation.StripeSubscriptionIDCleared() { + _spec.ClearField(orgsubscription.FieldStripeSubscriptionID, field.TypeString) + } + if value, ok := osu.mutation.ProductTier(); ok { + _spec.SetField(orgsubscription.FieldProductTier, field.TypeString, value) + } + if osu.mutation.ProductTierCleared() { + _spec.ClearField(orgsubscription.FieldProductTier, field.TypeString) + } + if value, ok := osu.mutation.StripeProductTierID(); ok { + _spec.SetField(orgsubscription.FieldStripeProductTierID, field.TypeString, value) + } + if osu.mutation.StripeProductTierIDCleared() { + _spec.ClearField(orgsubscription.FieldStripeProductTierID, field.TypeString) + } + if value, ok := osu.mutation.StripeSubscriptionStatus(); ok { + _spec.SetField(orgsubscription.FieldStripeSubscriptionStatus, field.TypeString, value) + } + if osu.mutation.StripeSubscriptionStatusCleared() { + _spec.ClearField(orgsubscription.FieldStripeSubscriptionStatus, field.TypeString) + } + if value, ok := osu.mutation.Active(); ok { + _spec.SetField(orgsubscription.FieldActive, field.TypeBool, value) + } + if value, ok := osu.mutation.StripeCustomerID(); ok { + _spec.SetField(orgsubscription.FieldStripeCustomerID, field.TypeString, value) + } + if osu.mutation.StripeCustomerIDCleared() { + _spec.ClearField(orgsubscription.FieldStripeCustomerID, field.TypeString) + } + if value, ok := osu.mutation.ExpiresAt(); ok { + _spec.SetField(orgsubscription.FieldExpiresAt, field.TypeTime, value) + } + if osu.mutation.ExpiresAtCleared() { + _spec.ClearField(orgsubscription.FieldExpiresAt, field.TypeTime) + } + if value, ok := osu.mutation.Features(); ok { + _spec.SetField(orgsubscription.FieldFeatures, field.TypeJSON, value) + } + if value, ok := osu.mutation.AppendedFeatures(); ok { + _spec.AddModifier(func(u *sql.UpdateBuilder) { + sqljson.Append(u, orgsubscription.FieldFeatures, value) + }) + } + if osu.mutation.FeaturesCleared() { + _spec.ClearField(orgsubscription.FieldFeatures, field.TypeJSON) + } + if osu.mutation.OwnerCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: orgsubscription.OwnerTable, + Columns: []string{orgsubscription.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(organization.FieldID, field.TypeString), + }, + } + edge.Schema = osu.schemaConfig.OrgSubscription + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := osu.mutation.OwnerIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: orgsubscription.OwnerTable, + Columns: []string{orgsubscription.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(organization.FieldID, field.TypeString), + }, + } + edge.Schema = osu.schemaConfig.OrgSubscription + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + _spec.Node.Schema = osu.schemaConfig.OrgSubscription + ctx = internal.NewSchemaConfigContext(ctx, osu.schemaConfig) + _spec.AddModifiers(osu.modifiers...) + if n, err = sqlgraph.UpdateNodes(ctx, osu.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{orgsubscription.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + osu.mutation.done = true + return n, nil +} + +// OrgSubscriptionUpdateOne is the builder for updating a single OrgSubscription entity. +type OrgSubscriptionUpdateOne struct { + config + fields []string + hooks []Hook + mutation *OrgSubscriptionMutation + modifiers []func(*sql.UpdateBuilder) +} + +// SetUpdatedAt sets the "updated_at" field. +func (osuo *OrgSubscriptionUpdateOne) SetUpdatedAt(t time.Time) *OrgSubscriptionUpdateOne { + osuo.mutation.SetUpdatedAt(t) + return osuo +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (osuo *OrgSubscriptionUpdateOne) ClearUpdatedAt() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearUpdatedAt() + return osuo +} + +// SetUpdatedBy sets the "updated_by" field. +func (osuo *OrgSubscriptionUpdateOne) SetUpdatedBy(s string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetUpdatedBy(s) + return osuo +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableUpdatedBy(s *string) *OrgSubscriptionUpdateOne { + if s != nil { + osuo.SetUpdatedBy(*s) + } + return osuo +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (osuo *OrgSubscriptionUpdateOne) ClearUpdatedBy() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearUpdatedBy() + return osuo +} + +// SetTags sets the "tags" field. +func (osuo *OrgSubscriptionUpdateOne) SetTags(s []string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetTags(s) + return osuo +} + +// AppendTags appends s to the "tags" field. +func (osuo *OrgSubscriptionUpdateOne) AppendTags(s []string) *OrgSubscriptionUpdateOne { + osuo.mutation.AppendTags(s) + return osuo +} + +// ClearTags clears the value of the "tags" field. +func (osuo *OrgSubscriptionUpdateOne) ClearTags() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearTags() + return osuo +} + +// SetDeletedAt sets the "deleted_at" field. +func (osuo *OrgSubscriptionUpdateOne) SetDeletedAt(t time.Time) *OrgSubscriptionUpdateOne { + osuo.mutation.SetDeletedAt(t) + return osuo +} + +// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableDeletedAt(t *time.Time) *OrgSubscriptionUpdateOne { + if t != nil { + osuo.SetDeletedAt(*t) + } + return osuo +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (osuo *OrgSubscriptionUpdateOne) ClearDeletedAt() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearDeletedAt() + return osuo +} + +// SetDeletedBy sets the "deleted_by" field. +func (osuo *OrgSubscriptionUpdateOne) SetDeletedBy(s string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetDeletedBy(s) + return osuo +} + +// SetNillableDeletedBy sets the "deleted_by" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableDeletedBy(s *string) *OrgSubscriptionUpdateOne { + if s != nil { + osuo.SetDeletedBy(*s) + } + return osuo +} + +// ClearDeletedBy clears the value of the "deleted_by" field. +func (osuo *OrgSubscriptionUpdateOne) ClearDeletedBy() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearDeletedBy() + return osuo +} + +// SetOwnerID sets the "owner_id" field. +func (osuo *OrgSubscriptionUpdateOne) SetOwnerID(s string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetOwnerID(s) + return osuo +} + +// SetNillableOwnerID sets the "owner_id" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableOwnerID(s *string) *OrgSubscriptionUpdateOne { + if s != nil { + osuo.SetOwnerID(*s) + } + return osuo +} + +// ClearOwnerID clears the value of the "owner_id" field. +func (osuo *OrgSubscriptionUpdateOne) ClearOwnerID() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearOwnerID() + return osuo +} + +// SetStripeSubscriptionID sets the "stripe_subscription_id" field. +func (osuo *OrgSubscriptionUpdateOne) SetStripeSubscriptionID(s string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetStripeSubscriptionID(s) + return osuo +} + +// SetNillableStripeSubscriptionID sets the "stripe_subscription_id" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableStripeSubscriptionID(s *string) *OrgSubscriptionUpdateOne { + if s != nil { + osuo.SetStripeSubscriptionID(*s) + } + return osuo +} + +// ClearStripeSubscriptionID clears the value of the "stripe_subscription_id" field. +func (osuo *OrgSubscriptionUpdateOne) ClearStripeSubscriptionID() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearStripeSubscriptionID() + return osuo +} + +// SetProductTier sets the "product_tier" field. +func (osuo *OrgSubscriptionUpdateOne) SetProductTier(s string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetProductTier(s) + return osuo +} + +// SetNillableProductTier sets the "product_tier" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableProductTier(s *string) *OrgSubscriptionUpdateOne { + if s != nil { + osuo.SetProductTier(*s) + } + return osuo +} + +// ClearProductTier clears the value of the "product_tier" field. +func (osuo *OrgSubscriptionUpdateOne) ClearProductTier() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearProductTier() + return osuo +} + +// SetStripeProductTierID sets the "stripe_product_tier_id" field. +func (osuo *OrgSubscriptionUpdateOne) SetStripeProductTierID(s string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetStripeProductTierID(s) + return osuo +} + +// SetNillableStripeProductTierID sets the "stripe_product_tier_id" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableStripeProductTierID(s *string) *OrgSubscriptionUpdateOne { + if s != nil { + osuo.SetStripeProductTierID(*s) + } + return osuo +} + +// ClearStripeProductTierID clears the value of the "stripe_product_tier_id" field. +func (osuo *OrgSubscriptionUpdateOne) ClearStripeProductTierID() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearStripeProductTierID() + return osuo +} + +// SetStripeSubscriptionStatus sets the "stripe_subscription_status" field. +func (osuo *OrgSubscriptionUpdateOne) SetStripeSubscriptionStatus(s string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetStripeSubscriptionStatus(s) + return osuo +} + +// SetNillableStripeSubscriptionStatus sets the "stripe_subscription_status" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableStripeSubscriptionStatus(s *string) *OrgSubscriptionUpdateOne { + if s != nil { + osuo.SetStripeSubscriptionStatus(*s) + } + return osuo +} + +// ClearStripeSubscriptionStatus clears the value of the "stripe_subscription_status" field. +func (osuo *OrgSubscriptionUpdateOne) ClearStripeSubscriptionStatus() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearStripeSubscriptionStatus() + return osuo +} + +// SetActive sets the "active" field. +func (osuo *OrgSubscriptionUpdateOne) SetActive(b bool) *OrgSubscriptionUpdateOne { + osuo.mutation.SetActive(b) + return osuo +} + +// SetNillableActive sets the "active" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableActive(b *bool) *OrgSubscriptionUpdateOne { + if b != nil { + osuo.SetActive(*b) + } + return osuo +} + +// SetStripeCustomerID sets the "stripe_customer_id" field. +func (osuo *OrgSubscriptionUpdateOne) SetStripeCustomerID(s string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetStripeCustomerID(s) + return osuo +} + +// SetNillableStripeCustomerID sets the "stripe_customer_id" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableStripeCustomerID(s *string) *OrgSubscriptionUpdateOne { + if s != nil { + osuo.SetStripeCustomerID(*s) + } + return osuo +} + +// ClearStripeCustomerID clears the value of the "stripe_customer_id" field. +func (osuo *OrgSubscriptionUpdateOne) ClearStripeCustomerID() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearStripeCustomerID() + return osuo +} + +// SetExpiresAt sets the "expires_at" field. +func (osuo *OrgSubscriptionUpdateOne) SetExpiresAt(t time.Time) *OrgSubscriptionUpdateOne { + osuo.mutation.SetExpiresAt(t) + return osuo +} + +// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil. +func (osuo *OrgSubscriptionUpdateOne) SetNillableExpiresAt(t *time.Time) *OrgSubscriptionUpdateOne { + if t != nil { + osuo.SetExpiresAt(*t) + } + return osuo +} + +// ClearExpiresAt clears the value of the "expires_at" field. +func (osuo *OrgSubscriptionUpdateOne) ClearExpiresAt() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearExpiresAt() + return osuo +} + +// SetFeatures sets the "features" field. +func (osuo *OrgSubscriptionUpdateOne) SetFeatures(s []string) *OrgSubscriptionUpdateOne { + osuo.mutation.SetFeatures(s) + return osuo +} + +// AppendFeatures appends s to the "features" field. +func (osuo *OrgSubscriptionUpdateOne) AppendFeatures(s []string) *OrgSubscriptionUpdateOne { + osuo.mutation.AppendFeatures(s) + return osuo +} + +// ClearFeatures clears the value of the "features" field. +func (osuo *OrgSubscriptionUpdateOne) ClearFeatures() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearFeatures() + return osuo +} + +// SetOwner sets the "owner" edge to the Organization entity. +func (osuo *OrgSubscriptionUpdateOne) SetOwner(o *Organization) *OrgSubscriptionUpdateOne { + return osuo.SetOwnerID(o.ID) +} + +// Mutation returns the OrgSubscriptionMutation object of the builder. +func (osuo *OrgSubscriptionUpdateOne) Mutation() *OrgSubscriptionMutation { + return osuo.mutation +} + +// ClearOwner clears the "owner" edge to the Organization entity. +func (osuo *OrgSubscriptionUpdateOne) ClearOwner() *OrgSubscriptionUpdateOne { + osuo.mutation.ClearOwner() + return osuo +} + +// Where appends a list predicates to the OrgSubscriptionUpdate builder. +func (osuo *OrgSubscriptionUpdateOne) Where(ps ...predicate.OrgSubscription) *OrgSubscriptionUpdateOne { + osuo.mutation.Where(ps...) + return osuo +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (osuo *OrgSubscriptionUpdateOne) Select(field string, fields ...string) *OrgSubscriptionUpdateOne { + osuo.fields = append([]string{field}, fields...) + return osuo +} + +// Save executes the query and returns the updated OrgSubscription entity. +func (osuo *OrgSubscriptionUpdateOne) Save(ctx context.Context) (*OrgSubscription, error) { + if err := osuo.defaults(); err != nil { + return nil, err + } + return withHooks(ctx, osuo.sqlSave, osuo.mutation, osuo.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (osuo *OrgSubscriptionUpdateOne) SaveX(ctx context.Context) *OrgSubscription { + node, err := osuo.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (osuo *OrgSubscriptionUpdateOne) Exec(ctx context.Context) error { + _, err := osuo.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (osuo *OrgSubscriptionUpdateOne) ExecX(ctx context.Context) { + if err := osuo.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (osuo *OrgSubscriptionUpdateOne) defaults() error { + if _, ok := osuo.mutation.UpdatedAt(); !ok && !osuo.mutation.UpdatedAtCleared() { + if orgsubscription.UpdateDefaultUpdatedAt == nil { + return fmt.Errorf("generated: uninitialized orgsubscription.UpdateDefaultUpdatedAt (forgotten import generated/runtime?)") + } + v := orgsubscription.UpdateDefaultUpdatedAt() + osuo.mutation.SetUpdatedAt(v) + } + return nil +} + +// check runs all checks and user-defined validators on the builder. +func (osuo *OrgSubscriptionUpdateOne) check() error { + if v, ok := osuo.mutation.OwnerID(); ok { + if err := orgsubscription.OwnerIDValidator(v); err != nil { + return &ValidationError{Name: "owner_id", err: fmt.Errorf(`generated: validator failed for field "OrgSubscription.owner_id": %w`, err)} + } + } + return nil +} + +// Modify adds a statement modifier for attaching custom logic to the UPDATE statement. +func (osuo *OrgSubscriptionUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *OrgSubscriptionUpdateOne { + osuo.modifiers = append(osuo.modifiers, modifiers...) + return osuo +} + +func (osuo *OrgSubscriptionUpdateOne) sqlSave(ctx context.Context) (_node *OrgSubscription, err error) { + if err := osuo.check(); err != nil { + return _node, err + } + _spec := sqlgraph.NewUpdateSpec(orgsubscription.Table, orgsubscription.Columns, sqlgraph.NewFieldSpec(orgsubscription.FieldID, field.TypeString)) + id, ok := osuo.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`generated: missing "OrgSubscription.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := osuo.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, orgsubscription.FieldID) + for _, f := range fields { + if !orgsubscription.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("generated: invalid field %q for query", f)} + } + if f != orgsubscription.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := osuo.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if osuo.mutation.CreatedAtCleared() { + _spec.ClearField(orgsubscription.FieldCreatedAt, field.TypeTime) + } + if value, ok := osuo.mutation.UpdatedAt(); ok { + _spec.SetField(orgsubscription.FieldUpdatedAt, field.TypeTime, value) + } + if osuo.mutation.UpdatedAtCleared() { + _spec.ClearField(orgsubscription.FieldUpdatedAt, field.TypeTime) + } + if osuo.mutation.CreatedByCleared() { + _spec.ClearField(orgsubscription.FieldCreatedBy, field.TypeString) + } + if value, ok := osuo.mutation.UpdatedBy(); ok { + _spec.SetField(orgsubscription.FieldUpdatedBy, field.TypeString, value) + } + if osuo.mutation.UpdatedByCleared() { + _spec.ClearField(orgsubscription.FieldUpdatedBy, field.TypeString) + } + if value, ok := osuo.mutation.Tags(); ok { + _spec.SetField(orgsubscription.FieldTags, field.TypeJSON, value) + } + if value, ok := osuo.mutation.AppendedTags(); ok { + _spec.AddModifier(func(u *sql.UpdateBuilder) { + sqljson.Append(u, orgsubscription.FieldTags, value) + }) + } + if osuo.mutation.TagsCleared() { + _spec.ClearField(orgsubscription.FieldTags, field.TypeJSON) + } + if value, ok := osuo.mutation.DeletedAt(); ok { + _spec.SetField(orgsubscription.FieldDeletedAt, field.TypeTime, value) + } + if osuo.mutation.DeletedAtCleared() { + _spec.ClearField(orgsubscription.FieldDeletedAt, field.TypeTime) + } + if value, ok := osuo.mutation.DeletedBy(); ok { + _spec.SetField(orgsubscription.FieldDeletedBy, field.TypeString, value) + } + if osuo.mutation.DeletedByCleared() { + _spec.ClearField(orgsubscription.FieldDeletedBy, field.TypeString) + } + if value, ok := osuo.mutation.StripeSubscriptionID(); ok { + _spec.SetField(orgsubscription.FieldStripeSubscriptionID, field.TypeString, value) + } + if osuo.mutation.StripeSubscriptionIDCleared() { + _spec.ClearField(orgsubscription.FieldStripeSubscriptionID, field.TypeString) + } + if value, ok := osuo.mutation.ProductTier(); ok { + _spec.SetField(orgsubscription.FieldProductTier, field.TypeString, value) + } + if osuo.mutation.ProductTierCleared() { + _spec.ClearField(orgsubscription.FieldProductTier, field.TypeString) + } + if value, ok := osuo.mutation.StripeProductTierID(); ok { + _spec.SetField(orgsubscription.FieldStripeProductTierID, field.TypeString, value) + } + if osuo.mutation.StripeProductTierIDCleared() { + _spec.ClearField(orgsubscription.FieldStripeProductTierID, field.TypeString) + } + if value, ok := osuo.mutation.StripeSubscriptionStatus(); ok { + _spec.SetField(orgsubscription.FieldStripeSubscriptionStatus, field.TypeString, value) + } + if osuo.mutation.StripeSubscriptionStatusCleared() { + _spec.ClearField(orgsubscription.FieldStripeSubscriptionStatus, field.TypeString) + } + if value, ok := osuo.mutation.Active(); ok { + _spec.SetField(orgsubscription.FieldActive, field.TypeBool, value) + } + if value, ok := osuo.mutation.StripeCustomerID(); ok { + _spec.SetField(orgsubscription.FieldStripeCustomerID, field.TypeString, value) + } + if osuo.mutation.StripeCustomerIDCleared() { + _spec.ClearField(orgsubscription.FieldStripeCustomerID, field.TypeString) + } + if value, ok := osuo.mutation.ExpiresAt(); ok { + _spec.SetField(orgsubscription.FieldExpiresAt, field.TypeTime, value) + } + if osuo.mutation.ExpiresAtCleared() { + _spec.ClearField(orgsubscription.FieldExpiresAt, field.TypeTime) + } + if value, ok := osuo.mutation.Features(); ok { + _spec.SetField(orgsubscription.FieldFeatures, field.TypeJSON, value) + } + if value, ok := osuo.mutation.AppendedFeatures(); ok { + _spec.AddModifier(func(u *sql.UpdateBuilder) { + sqljson.Append(u, orgsubscription.FieldFeatures, value) + }) + } + if osuo.mutation.FeaturesCleared() { + _spec.ClearField(orgsubscription.FieldFeatures, field.TypeJSON) + } + if osuo.mutation.OwnerCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: orgsubscription.OwnerTable, + Columns: []string{orgsubscription.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(organization.FieldID, field.TypeString), + }, + } + edge.Schema = osuo.schemaConfig.OrgSubscription + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := osuo.mutation.OwnerIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: orgsubscription.OwnerTable, + Columns: []string{orgsubscription.OwnerColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: sqlgraph.NewFieldSpec(organization.FieldID, field.TypeString), + }, + } + edge.Schema = osuo.schemaConfig.OrgSubscription + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + _spec.Node.Schema = osuo.schemaConfig.OrgSubscription + ctx = internal.NewSchemaConfigContext(ctx, osuo.schemaConfig) + _spec.AddModifiers(osuo.modifiers...) + _node = &OrgSubscription{config: osuo.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, osuo.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{orgsubscription.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + osuo.mutation.done = true + return _node, nil +} diff --git a/internal/ent/generated/orgsubscriptionhistory.go b/internal/ent/generated/orgsubscriptionhistory.go new file mode 100644 index 00000000..1f585c24 --- /dev/null +++ b/internal/ent/generated/orgsubscriptionhistory.go @@ -0,0 +1,328 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "encoding/json" + "fmt" + "strings" + "time" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" + "github.com/theopenlane/entx/history" +) + +// OrgSubscriptionHistory is the model entity for the OrgSubscriptionHistory schema. +type OrgSubscriptionHistory struct { + config `json:"-"` + // ID of the ent. + ID string `json:"id,omitempty"` + // HistoryTime holds the value of the "history_time" field. + HistoryTime time.Time `json:"history_time,omitempty"` + // Ref holds the value of the "ref" field. + Ref string `json:"ref,omitempty"` + // Operation holds the value of the "operation" field. + Operation history.OpType `json:"operation,omitempty"` + // CreatedAt holds the value of the "created_at" field. + CreatedAt time.Time `json:"created_at,omitempty"` + // UpdatedAt holds the value of the "updated_at" field. + UpdatedAt time.Time `json:"updated_at,omitempty"` + // CreatedBy holds the value of the "created_by" field. + CreatedBy string `json:"created_by,omitempty"` + // UpdatedBy holds the value of the "updated_by" field. + UpdatedBy string `json:"updated_by,omitempty"` + // MappingID holds the value of the "mapping_id" field. + MappingID string `json:"mapping_id,omitempty"` + // tags associated with the object + Tags []string `json:"tags,omitempty"` + // DeletedAt holds the value of the "deleted_at" field. + DeletedAt time.Time `json:"deleted_at,omitempty"` + // DeletedBy holds the value of the "deleted_by" field. + DeletedBy string `json:"deleted_by,omitempty"` + // the organization id that owns the object + OwnerID string `json:"owner_id,omitempty"` + // the stripe subscription id + StripeSubscriptionID string `json:"stripe_subscription_id,omitempty"` + // the common name of the product tier the subscription is associated with, e.g. starter tier + ProductTier string `json:"product_tier,omitempty"` + // the product id that represents the tier in stripe + StripeProductTierID string `json:"stripe_product_tier_id,omitempty"` + // the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + StripeSubscriptionStatus string `json:"stripe_subscription_status,omitempty"` + // indicates if the subscription is active + Active bool `json:"active,omitempty"` + // the customer ID the subscription is associated to + StripeCustomerID string `json:"stripe_customer_id,omitempty"` + // the time the subscription is set to expire; only populated if subscription is cancelled + ExpiresAt *time.Time `json:"expires_at,omitempty"` + // the features associated with the subscription + Features []string `json:"features,omitempty"` + selectValues sql.SelectValues +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*OrgSubscriptionHistory) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case orgsubscriptionhistory.FieldTags, orgsubscriptionhistory.FieldFeatures: + values[i] = new([]byte) + case orgsubscriptionhistory.FieldOperation: + values[i] = new(history.OpType) + case orgsubscriptionhistory.FieldActive: + values[i] = new(sql.NullBool) + case orgsubscriptionhistory.FieldID, orgsubscriptionhistory.FieldRef, orgsubscriptionhistory.FieldCreatedBy, orgsubscriptionhistory.FieldUpdatedBy, orgsubscriptionhistory.FieldMappingID, orgsubscriptionhistory.FieldDeletedBy, orgsubscriptionhistory.FieldOwnerID, orgsubscriptionhistory.FieldStripeSubscriptionID, orgsubscriptionhistory.FieldProductTier, orgsubscriptionhistory.FieldStripeProductTierID, orgsubscriptionhistory.FieldStripeSubscriptionStatus, orgsubscriptionhistory.FieldStripeCustomerID: + values[i] = new(sql.NullString) + case orgsubscriptionhistory.FieldHistoryTime, orgsubscriptionhistory.FieldCreatedAt, orgsubscriptionhistory.FieldUpdatedAt, orgsubscriptionhistory.FieldDeletedAt, orgsubscriptionhistory.FieldExpiresAt: + values[i] = new(sql.NullTime) + default: + values[i] = new(sql.UnknownType) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the OrgSubscriptionHistory fields. +func (osh *OrgSubscriptionHistory) assignValues(columns []string, values []any) error { + if m, n := len(values), len(columns); m < n { + return fmt.Errorf("mismatch number of scan values: %d != %d", m, n) + } + for i := range columns { + switch columns[i] { + case orgsubscriptionhistory.FieldID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field id", values[i]) + } else if value.Valid { + osh.ID = value.String + } + case orgsubscriptionhistory.FieldHistoryTime: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field history_time", values[i]) + } else if value.Valid { + osh.HistoryTime = value.Time + } + case orgsubscriptionhistory.FieldRef: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field ref", values[i]) + } else if value.Valid { + osh.Ref = value.String + } + case orgsubscriptionhistory.FieldOperation: + if value, ok := values[i].(*history.OpType); !ok { + return fmt.Errorf("unexpected type %T for field operation", values[i]) + } else if value != nil { + osh.Operation = *value + } + case orgsubscriptionhistory.FieldCreatedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field created_at", values[i]) + } else if value.Valid { + osh.CreatedAt = value.Time + } + case orgsubscriptionhistory.FieldUpdatedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field updated_at", values[i]) + } else if value.Valid { + osh.UpdatedAt = value.Time + } + case orgsubscriptionhistory.FieldCreatedBy: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field created_by", values[i]) + } else if value.Valid { + osh.CreatedBy = value.String + } + case orgsubscriptionhistory.FieldUpdatedBy: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field updated_by", values[i]) + } else if value.Valid { + osh.UpdatedBy = value.String + } + case orgsubscriptionhistory.FieldMappingID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field mapping_id", values[i]) + } else if value.Valid { + osh.MappingID = value.String + } + case orgsubscriptionhistory.FieldTags: + if value, ok := values[i].(*[]byte); !ok { + return fmt.Errorf("unexpected type %T for field tags", values[i]) + } else if value != nil && len(*value) > 0 { + if err := json.Unmarshal(*value, &osh.Tags); err != nil { + return fmt.Errorf("unmarshal field tags: %w", err) + } + } + case orgsubscriptionhistory.FieldDeletedAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field deleted_at", values[i]) + } else if value.Valid { + osh.DeletedAt = value.Time + } + case orgsubscriptionhistory.FieldDeletedBy: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field deleted_by", values[i]) + } else if value.Valid { + osh.DeletedBy = value.String + } + case orgsubscriptionhistory.FieldOwnerID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field owner_id", values[i]) + } else if value.Valid { + osh.OwnerID = value.String + } + case orgsubscriptionhistory.FieldStripeSubscriptionID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field stripe_subscription_id", values[i]) + } else if value.Valid { + osh.StripeSubscriptionID = value.String + } + case orgsubscriptionhistory.FieldProductTier: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field product_tier", values[i]) + } else if value.Valid { + osh.ProductTier = value.String + } + case orgsubscriptionhistory.FieldStripeProductTierID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field stripe_product_tier_id", values[i]) + } else if value.Valid { + osh.StripeProductTierID = value.String + } + case orgsubscriptionhistory.FieldStripeSubscriptionStatus: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field stripe_subscription_status", values[i]) + } else if value.Valid { + osh.StripeSubscriptionStatus = value.String + } + case orgsubscriptionhistory.FieldActive: + if value, ok := values[i].(*sql.NullBool); !ok { + return fmt.Errorf("unexpected type %T for field active", values[i]) + } else if value.Valid { + osh.Active = value.Bool + } + case orgsubscriptionhistory.FieldStripeCustomerID: + if value, ok := values[i].(*sql.NullString); !ok { + return fmt.Errorf("unexpected type %T for field stripe_customer_id", values[i]) + } else if value.Valid { + osh.StripeCustomerID = value.String + } + case orgsubscriptionhistory.FieldExpiresAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field expires_at", values[i]) + } else if value.Valid { + osh.ExpiresAt = new(time.Time) + *osh.ExpiresAt = value.Time + } + case orgsubscriptionhistory.FieldFeatures: + if value, ok := values[i].(*[]byte); !ok { + return fmt.Errorf("unexpected type %T for field features", values[i]) + } else if value != nil && len(*value) > 0 { + if err := json.Unmarshal(*value, &osh.Features); err != nil { + return fmt.Errorf("unmarshal field features: %w", err) + } + } + default: + osh.selectValues.Set(columns[i], values[i]) + } + } + return nil +} + +// Value returns the ent.Value that was dynamically selected and assigned to the OrgSubscriptionHistory. +// This includes values selected through modifiers, order, etc. +func (osh *OrgSubscriptionHistory) Value(name string) (ent.Value, error) { + return osh.selectValues.Get(name) +} + +// Update returns a builder for updating this OrgSubscriptionHistory. +// Note that you need to call OrgSubscriptionHistory.Unwrap() before calling this method if this OrgSubscriptionHistory +// was returned from a transaction, and the transaction was committed or rolled back. +func (osh *OrgSubscriptionHistory) Update() *OrgSubscriptionHistoryUpdateOne { + return NewOrgSubscriptionHistoryClient(osh.config).UpdateOne(osh) +} + +// Unwrap unwraps the OrgSubscriptionHistory entity that was returned from a transaction after it was closed, +// so that all future queries will be executed through the driver which created the transaction. +func (osh *OrgSubscriptionHistory) Unwrap() *OrgSubscriptionHistory { + _tx, ok := osh.config.driver.(*txDriver) + if !ok { + panic("generated: OrgSubscriptionHistory is not a transactional entity") + } + osh.config.driver = _tx.drv + return osh +} + +// String implements the fmt.Stringer. +func (osh *OrgSubscriptionHistory) String() string { + var builder strings.Builder + builder.WriteString("OrgSubscriptionHistory(") + builder.WriteString(fmt.Sprintf("id=%v, ", osh.ID)) + builder.WriteString("history_time=") + builder.WriteString(osh.HistoryTime.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("ref=") + builder.WriteString(osh.Ref) + builder.WriteString(", ") + builder.WriteString("operation=") + builder.WriteString(fmt.Sprintf("%v", osh.Operation)) + builder.WriteString(", ") + builder.WriteString("created_at=") + builder.WriteString(osh.CreatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("updated_at=") + builder.WriteString(osh.UpdatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("created_by=") + builder.WriteString(osh.CreatedBy) + builder.WriteString(", ") + builder.WriteString("updated_by=") + builder.WriteString(osh.UpdatedBy) + builder.WriteString(", ") + builder.WriteString("mapping_id=") + builder.WriteString(osh.MappingID) + builder.WriteString(", ") + builder.WriteString("tags=") + builder.WriteString(fmt.Sprintf("%v", osh.Tags)) + builder.WriteString(", ") + builder.WriteString("deleted_at=") + builder.WriteString(osh.DeletedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("deleted_by=") + builder.WriteString(osh.DeletedBy) + builder.WriteString(", ") + builder.WriteString("owner_id=") + builder.WriteString(osh.OwnerID) + builder.WriteString(", ") + builder.WriteString("stripe_subscription_id=") + builder.WriteString(osh.StripeSubscriptionID) + builder.WriteString(", ") + builder.WriteString("product_tier=") + builder.WriteString(osh.ProductTier) + builder.WriteString(", ") + builder.WriteString("stripe_product_tier_id=") + builder.WriteString(osh.StripeProductTierID) + builder.WriteString(", ") + builder.WriteString("stripe_subscription_status=") + builder.WriteString(osh.StripeSubscriptionStatus) + builder.WriteString(", ") + builder.WriteString("active=") + builder.WriteString(fmt.Sprintf("%v", osh.Active)) + builder.WriteString(", ") + builder.WriteString("stripe_customer_id=") + builder.WriteString(osh.StripeCustomerID) + builder.WriteString(", ") + if v := osh.ExpiresAt; v != nil { + builder.WriteString("expires_at=") + builder.WriteString(v.Format(time.ANSIC)) + } + builder.WriteString(", ") + builder.WriteString("features=") + builder.WriteString(fmt.Sprintf("%v", osh.Features)) + builder.WriteByte(')') + return builder.String() +} + +// OrgSubscriptionHistories is a parsable slice of OrgSubscriptionHistory. +type OrgSubscriptionHistories []*OrgSubscriptionHistory diff --git a/internal/ent/generated/orgsubscriptionhistory/orgsubscriptionhistory.go b/internal/ent/generated/orgsubscriptionhistory/orgsubscriptionhistory.go new file mode 100644 index 00000000..88a505e9 --- /dev/null +++ b/internal/ent/generated/orgsubscriptionhistory/orgsubscriptionhistory.go @@ -0,0 +1,230 @@ +// Code generated by ent, DO NOT EDIT. + +package orgsubscriptionhistory + +import ( + "fmt" + "time" + + "entgo.io/ent/dialect/sql" + "github.com/99designs/gqlgen/graphql" + "github.com/theopenlane/entx/history" +) + +const ( + // Label holds the string label denoting the orgsubscriptionhistory type in the database. + Label = "org_subscription_history" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldHistoryTime holds the string denoting the history_time field in the database. + FieldHistoryTime = "history_time" + // FieldRef holds the string denoting the ref field in the database. + FieldRef = "ref" + // FieldOperation holds the string denoting the operation field in the database. + FieldOperation = "operation" + // FieldCreatedAt holds the string denoting the created_at field in the database. + FieldCreatedAt = "created_at" + // FieldUpdatedAt holds the string denoting the updated_at field in the database. + FieldUpdatedAt = "updated_at" + // FieldCreatedBy holds the string denoting the created_by field in the database. + FieldCreatedBy = "created_by" + // FieldUpdatedBy holds the string denoting the updated_by field in the database. + FieldUpdatedBy = "updated_by" + // FieldMappingID holds the string denoting the mapping_id field in the database. + FieldMappingID = "mapping_id" + // FieldTags holds the string denoting the tags field in the database. + FieldTags = "tags" + // FieldDeletedAt holds the string denoting the deleted_at field in the database. + FieldDeletedAt = "deleted_at" + // FieldDeletedBy holds the string denoting the deleted_by field in the database. + FieldDeletedBy = "deleted_by" + // FieldOwnerID holds the string denoting the owner_id field in the database. + FieldOwnerID = "owner_id" + // FieldStripeSubscriptionID holds the string denoting the stripe_subscription_id field in the database. + FieldStripeSubscriptionID = "stripe_subscription_id" + // FieldProductTier holds the string denoting the product_tier field in the database. + FieldProductTier = "product_tier" + // FieldStripeProductTierID holds the string denoting the stripe_product_tier_id field in the database. + FieldStripeProductTierID = "stripe_product_tier_id" + // FieldStripeSubscriptionStatus holds the string denoting the stripe_subscription_status field in the database. + FieldStripeSubscriptionStatus = "stripe_subscription_status" + // FieldActive holds the string denoting the active field in the database. + FieldActive = "active" + // FieldStripeCustomerID holds the string denoting the stripe_customer_id field in the database. + FieldStripeCustomerID = "stripe_customer_id" + // FieldExpiresAt holds the string denoting the expires_at field in the database. + FieldExpiresAt = "expires_at" + // FieldFeatures holds the string denoting the features field in the database. + FieldFeatures = "features" + // Table holds the table name of the orgsubscriptionhistory in the database. + Table = "org_subscription_history" +) + +// Columns holds all SQL columns for orgsubscriptionhistory fields. +var Columns = []string{ + FieldID, + FieldHistoryTime, + FieldRef, + FieldOperation, + FieldCreatedAt, + FieldUpdatedAt, + FieldCreatedBy, + FieldUpdatedBy, + FieldMappingID, + FieldTags, + FieldDeletedAt, + FieldDeletedBy, + FieldOwnerID, + FieldStripeSubscriptionID, + FieldProductTier, + FieldStripeProductTierID, + FieldStripeSubscriptionStatus, + FieldActive, + FieldStripeCustomerID, + FieldExpiresAt, + FieldFeatures, +} + +// ValidColumn reports if the column name is valid (part of the table columns). +func ValidColumn(column string) bool { + for i := range Columns { + if column == Columns[i] { + return true + } + } + return false +} + +var ( + // DefaultHistoryTime holds the default value on creation for the "history_time" field. + DefaultHistoryTime func() time.Time + // DefaultCreatedAt holds the default value on creation for the "created_at" field. + DefaultCreatedAt func() time.Time + // DefaultUpdatedAt holds the default value on creation for the "updated_at" field. + DefaultUpdatedAt func() time.Time + // UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field. + UpdateDefaultUpdatedAt func() time.Time + // DefaultMappingID holds the default value on creation for the "mapping_id" field. + DefaultMappingID func() string + // DefaultTags holds the default value on creation for the "tags" field. + DefaultTags []string + // DefaultActive holds the default value on creation for the "active" field. + DefaultActive bool + // DefaultID holds the default value on creation for the "id" field. + DefaultID func() string +) + +// OperationValidator is a validator for the "operation" field enum values. It is called by the builders before save. +func OperationValidator(o history.OpType) error { + switch o.String() { + case "INSERT", "UPDATE", "DELETE": + return nil + default: + return fmt.Errorf("orgsubscriptionhistory: invalid enum value for operation field: %q", o) + } +} + +// OrderOption defines the ordering options for the OrgSubscriptionHistory queries. +type OrderOption func(*sql.Selector) + +// ByID orders the results by the id field. +func ByID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldID, opts...).ToFunc() +} + +// ByHistoryTime orders the results by the history_time field. +func ByHistoryTime(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldHistoryTime, opts...).ToFunc() +} + +// ByRef orders the results by the ref field. +func ByRef(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldRef, opts...).ToFunc() +} + +// ByOperation orders the results by the operation field. +func ByOperation(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldOperation, opts...).ToFunc() +} + +// ByCreatedAt orders the results by the created_at field. +func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCreatedAt, opts...).ToFunc() +} + +// ByUpdatedAt orders the results by the updated_at field. +func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc() +} + +// ByCreatedBy orders the results by the created_by field. +func ByCreatedBy(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldCreatedBy, opts...).ToFunc() +} + +// ByUpdatedBy orders the results by the updated_by field. +func ByUpdatedBy(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldUpdatedBy, opts...).ToFunc() +} + +// ByMappingID orders the results by the mapping_id field. +func ByMappingID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldMappingID, opts...).ToFunc() +} + +// ByDeletedAt orders the results by the deleted_at field. +func ByDeletedAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldDeletedAt, opts...).ToFunc() +} + +// ByDeletedBy orders the results by the deleted_by field. +func ByDeletedBy(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldDeletedBy, opts...).ToFunc() +} + +// ByOwnerID orders the results by the owner_id field. +func ByOwnerID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldOwnerID, opts...).ToFunc() +} + +// ByStripeSubscriptionID orders the results by the stripe_subscription_id field. +func ByStripeSubscriptionID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStripeSubscriptionID, opts...).ToFunc() +} + +// ByProductTier orders the results by the product_tier field. +func ByProductTier(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldProductTier, opts...).ToFunc() +} + +// ByStripeProductTierID orders the results by the stripe_product_tier_id field. +func ByStripeProductTierID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStripeProductTierID, opts...).ToFunc() +} + +// ByStripeSubscriptionStatus orders the results by the stripe_subscription_status field. +func ByStripeSubscriptionStatus(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStripeSubscriptionStatus, opts...).ToFunc() +} + +// ByActive orders the results by the active field. +func ByActive(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldActive, opts...).ToFunc() +} + +// ByStripeCustomerID orders the results by the stripe_customer_id field. +func ByStripeCustomerID(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldStripeCustomerID, opts...).ToFunc() +} + +// ByExpiresAt orders the results by the expires_at field. +func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption { + return sql.OrderByField(FieldExpiresAt, opts...).ToFunc() +} + +var ( + // history.OpType must implement graphql.Marshaler. + _ graphql.Marshaler = (*history.OpType)(nil) + // history.OpType must implement graphql.Unmarshaler. + _ graphql.Unmarshaler = (*history.OpType)(nil) +) diff --git a/internal/ent/generated/orgsubscriptionhistory/where.go b/internal/ent/generated/orgsubscriptionhistory/where.go new file mode 100644 index 00000000..3df18d3a --- /dev/null +++ b/internal/ent/generated/orgsubscriptionhistory/where.go @@ -0,0 +1,1271 @@ +// Code generated by ent, DO NOT EDIT. + +package orgsubscriptionhistory + +import ( + "time" + + "entgo.io/ent/dialect/sql" + "github.com/theopenlane/core/internal/ent/generated/predicate" + "github.com/theopenlane/entx/history" +) + +// ID filters vertices based on their ID field. +func ID(id string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldID, id)) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldID, id)) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldID, id)) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldID, ids...)) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldID, ids...)) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldID, id)) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldID, id)) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldID, id)) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldID, id)) +} + +// IDEqualFold applies the EqualFold predicate on the ID field. +func IDEqualFold(id string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldID, id)) +} + +// IDContainsFold applies the ContainsFold predicate on the ID field. +func IDContainsFold(id string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldID, id)) +} + +// HistoryTime applies equality check predicate on the "history_time" field. It's identical to HistoryTimeEQ. +func HistoryTime(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldHistoryTime, v)) +} + +// Ref applies equality check predicate on the "ref" field. It's identical to RefEQ. +func Ref(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldRef, v)) +} + +// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ. +func CreatedAt(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldCreatedAt, v)) +} + +// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ. +func UpdatedAt(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// CreatedBy applies equality check predicate on the "created_by" field. It's identical to CreatedByEQ. +func CreatedBy(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldCreatedBy, v)) +} + +// UpdatedBy applies equality check predicate on the "updated_by" field. It's identical to UpdatedByEQ. +func UpdatedBy(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldUpdatedBy, v)) +} + +// MappingID applies equality check predicate on the "mapping_id" field. It's identical to MappingIDEQ. +func MappingID(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldMappingID, v)) +} + +// DeletedAt applies equality check predicate on the "deleted_at" field. It's identical to DeletedAtEQ. +func DeletedAt(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldDeletedAt, v)) +} + +// DeletedBy applies equality check predicate on the "deleted_by" field. It's identical to DeletedByEQ. +func DeletedBy(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldDeletedBy, v)) +} + +// OwnerID applies equality check predicate on the "owner_id" field. It's identical to OwnerIDEQ. +func OwnerID(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldOwnerID, v)) +} + +// StripeSubscriptionID applies equality check predicate on the "stripe_subscription_id" field. It's identical to StripeSubscriptionIDEQ. +func StripeSubscriptionID(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldStripeSubscriptionID, v)) +} + +// ProductTier applies equality check predicate on the "product_tier" field. It's identical to ProductTierEQ. +func ProductTier(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldProductTier, v)) +} + +// StripeProductTierID applies equality check predicate on the "stripe_product_tier_id" field. It's identical to StripeProductTierIDEQ. +func StripeProductTierID(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldStripeProductTierID, v)) +} + +// StripeSubscriptionStatus applies equality check predicate on the "stripe_subscription_status" field. It's identical to StripeSubscriptionStatusEQ. +func StripeSubscriptionStatus(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldStripeSubscriptionStatus, v)) +} + +// Active applies equality check predicate on the "active" field. It's identical to ActiveEQ. +func Active(v bool) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldActive, v)) +} + +// StripeCustomerID applies equality check predicate on the "stripe_customer_id" field. It's identical to StripeCustomerIDEQ. +func StripeCustomerID(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldStripeCustomerID, v)) +} + +// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ. +func ExpiresAt(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldExpiresAt, v)) +} + +// HistoryTimeEQ applies the EQ predicate on the "history_time" field. +func HistoryTimeEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldHistoryTime, v)) +} + +// HistoryTimeNEQ applies the NEQ predicate on the "history_time" field. +func HistoryTimeNEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldHistoryTime, v)) +} + +// HistoryTimeIn applies the In predicate on the "history_time" field. +func HistoryTimeIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldHistoryTime, vs...)) +} + +// HistoryTimeNotIn applies the NotIn predicate on the "history_time" field. +func HistoryTimeNotIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldHistoryTime, vs...)) +} + +// HistoryTimeGT applies the GT predicate on the "history_time" field. +func HistoryTimeGT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldHistoryTime, v)) +} + +// HistoryTimeGTE applies the GTE predicate on the "history_time" field. +func HistoryTimeGTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldHistoryTime, v)) +} + +// HistoryTimeLT applies the LT predicate on the "history_time" field. +func HistoryTimeLT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldHistoryTime, v)) +} + +// HistoryTimeLTE applies the LTE predicate on the "history_time" field. +func HistoryTimeLTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldHistoryTime, v)) +} + +// RefEQ applies the EQ predicate on the "ref" field. +func RefEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldRef, v)) +} + +// RefNEQ applies the NEQ predicate on the "ref" field. +func RefNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldRef, v)) +} + +// RefIn applies the In predicate on the "ref" field. +func RefIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldRef, vs...)) +} + +// RefNotIn applies the NotIn predicate on the "ref" field. +func RefNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldRef, vs...)) +} + +// RefGT applies the GT predicate on the "ref" field. +func RefGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldRef, v)) +} + +// RefGTE applies the GTE predicate on the "ref" field. +func RefGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldRef, v)) +} + +// RefLT applies the LT predicate on the "ref" field. +func RefLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldRef, v)) +} + +// RefLTE applies the LTE predicate on the "ref" field. +func RefLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldRef, v)) +} + +// RefContains applies the Contains predicate on the "ref" field. +func RefContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldRef, v)) +} + +// RefHasPrefix applies the HasPrefix predicate on the "ref" field. +func RefHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldRef, v)) +} + +// RefHasSuffix applies the HasSuffix predicate on the "ref" field. +func RefHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldRef, v)) +} + +// RefIsNil applies the IsNil predicate on the "ref" field. +func RefIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldRef)) +} + +// RefNotNil applies the NotNil predicate on the "ref" field. +func RefNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldRef)) +} + +// RefEqualFold applies the EqualFold predicate on the "ref" field. +func RefEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldRef, v)) +} + +// RefContainsFold applies the ContainsFold predicate on the "ref" field. +func RefContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldRef, v)) +} + +// OperationEQ applies the EQ predicate on the "operation" field. +func OperationEQ(v history.OpType) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldOperation, v)) +} + +// OperationNEQ applies the NEQ predicate on the "operation" field. +func OperationNEQ(v history.OpType) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldOperation, v)) +} + +// OperationIn applies the In predicate on the "operation" field. +func OperationIn(vs ...history.OpType) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldOperation, vs...)) +} + +// OperationNotIn applies the NotIn predicate on the "operation" field. +func OperationNotIn(vs ...history.OpType) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldOperation, vs...)) +} + +// CreatedAtEQ applies the EQ predicate on the "created_at" field. +func CreatedAtEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldCreatedAt, v)) +} + +// CreatedAtNEQ applies the NEQ predicate on the "created_at" field. +func CreatedAtNEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldCreatedAt, v)) +} + +// CreatedAtIn applies the In predicate on the "created_at" field. +func CreatedAtIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldCreatedAt, vs...)) +} + +// CreatedAtNotIn applies the NotIn predicate on the "created_at" field. +func CreatedAtNotIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldCreatedAt, vs...)) +} + +// CreatedAtGT applies the GT predicate on the "created_at" field. +func CreatedAtGT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldCreatedAt, v)) +} + +// CreatedAtGTE applies the GTE predicate on the "created_at" field. +func CreatedAtGTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldCreatedAt, v)) +} + +// CreatedAtLT applies the LT predicate on the "created_at" field. +func CreatedAtLT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldCreatedAt, v)) +} + +// CreatedAtLTE applies the LTE predicate on the "created_at" field. +func CreatedAtLTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldCreatedAt, v)) +} + +// CreatedAtIsNil applies the IsNil predicate on the "created_at" field. +func CreatedAtIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldCreatedAt)) +} + +// CreatedAtNotNil applies the NotNil predicate on the "created_at" field. +func CreatedAtNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldCreatedAt)) +} + +// UpdatedAtEQ applies the EQ predicate on the "updated_at" field. +func UpdatedAtEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field. +func UpdatedAtNEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldUpdatedAt, v)) +} + +// UpdatedAtIn applies the In predicate on the "updated_at" field. +func UpdatedAtIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field. +func UpdatedAtNotIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldUpdatedAt, vs...)) +} + +// UpdatedAtGT applies the GT predicate on the "updated_at" field. +func UpdatedAtGT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldUpdatedAt, v)) +} + +// UpdatedAtGTE applies the GTE predicate on the "updated_at" field. +func UpdatedAtGTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldUpdatedAt, v)) +} + +// UpdatedAtLT applies the LT predicate on the "updated_at" field. +func UpdatedAtLT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldUpdatedAt, v)) +} + +// UpdatedAtLTE applies the LTE predicate on the "updated_at" field. +func UpdatedAtLTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldUpdatedAt, v)) +} + +// UpdatedAtIsNil applies the IsNil predicate on the "updated_at" field. +func UpdatedAtIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldUpdatedAt)) +} + +// UpdatedAtNotNil applies the NotNil predicate on the "updated_at" field. +func UpdatedAtNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldUpdatedAt)) +} + +// CreatedByEQ applies the EQ predicate on the "created_by" field. +func CreatedByEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldCreatedBy, v)) +} + +// CreatedByNEQ applies the NEQ predicate on the "created_by" field. +func CreatedByNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldCreatedBy, v)) +} + +// CreatedByIn applies the In predicate on the "created_by" field. +func CreatedByIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldCreatedBy, vs...)) +} + +// CreatedByNotIn applies the NotIn predicate on the "created_by" field. +func CreatedByNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldCreatedBy, vs...)) +} + +// CreatedByGT applies the GT predicate on the "created_by" field. +func CreatedByGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldCreatedBy, v)) +} + +// CreatedByGTE applies the GTE predicate on the "created_by" field. +func CreatedByGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldCreatedBy, v)) +} + +// CreatedByLT applies the LT predicate on the "created_by" field. +func CreatedByLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldCreatedBy, v)) +} + +// CreatedByLTE applies the LTE predicate on the "created_by" field. +func CreatedByLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldCreatedBy, v)) +} + +// CreatedByContains applies the Contains predicate on the "created_by" field. +func CreatedByContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldCreatedBy, v)) +} + +// CreatedByHasPrefix applies the HasPrefix predicate on the "created_by" field. +func CreatedByHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldCreatedBy, v)) +} + +// CreatedByHasSuffix applies the HasSuffix predicate on the "created_by" field. +func CreatedByHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldCreatedBy, v)) +} + +// CreatedByIsNil applies the IsNil predicate on the "created_by" field. +func CreatedByIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldCreatedBy)) +} + +// CreatedByNotNil applies the NotNil predicate on the "created_by" field. +func CreatedByNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldCreatedBy)) +} + +// CreatedByEqualFold applies the EqualFold predicate on the "created_by" field. +func CreatedByEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldCreatedBy, v)) +} + +// CreatedByContainsFold applies the ContainsFold predicate on the "created_by" field. +func CreatedByContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldCreatedBy, v)) +} + +// UpdatedByEQ applies the EQ predicate on the "updated_by" field. +func UpdatedByEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldUpdatedBy, v)) +} + +// UpdatedByNEQ applies the NEQ predicate on the "updated_by" field. +func UpdatedByNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldUpdatedBy, v)) +} + +// UpdatedByIn applies the In predicate on the "updated_by" field. +func UpdatedByIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldUpdatedBy, vs...)) +} + +// UpdatedByNotIn applies the NotIn predicate on the "updated_by" field. +func UpdatedByNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldUpdatedBy, vs...)) +} + +// UpdatedByGT applies the GT predicate on the "updated_by" field. +func UpdatedByGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldUpdatedBy, v)) +} + +// UpdatedByGTE applies the GTE predicate on the "updated_by" field. +func UpdatedByGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldUpdatedBy, v)) +} + +// UpdatedByLT applies the LT predicate on the "updated_by" field. +func UpdatedByLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldUpdatedBy, v)) +} + +// UpdatedByLTE applies the LTE predicate on the "updated_by" field. +func UpdatedByLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldUpdatedBy, v)) +} + +// UpdatedByContains applies the Contains predicate on the "updated_by" field. +func UpdatedByContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldUpdatedBy, v)) +} + +// UpdatedByHasPrefix applies the HasPrefix predicate on the "updated_by" field. +func UpdatedByHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldUpdatedBy, v)) +} + +// UpdatedByHasSuffix applies the HasSuffix predicate on the "updated_by" field. +func UpdatedByHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldUpdatedBy, v)) +} + +// UpdatedByIsNil applies the IsNil predicate on the "updated_by" field. +func UpdatedByIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldUpdatedBy)) +} + +// UpdatedByNotNil applies the NotNil predicate on the "updated_by" field. +func UpdatedByNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldUpdatedBy)) +} + +// UpdatedByEqualFold applies the EqualFold predicate on the "updated_by" field. +func UpdatedByEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldUpdatedBy, v)) +} + +// UpdatedByContainsFold applies the ContainsFold predicate on the "updated_by" field. +func UpdatedByContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldUpdatedBy, v)) +} + +// MappingIDEQ applies the EQ predicate on the "mapping_id" field. +func MappingIDEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldMappingID, v)) +} + +// MappingIDNEQ applies the NEQ predicate on the "mapping_id" field. +func MappingIDNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldMappingID, v)) +} + +// MappingIDIn applies the In predicate on the "mapping_id" field. +func MappingIDIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldMappingID, vs...)) +} + +// MappingIDNotIn applies the NotIn predicate on the "mapping_id" field. +func MappingIDNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldMappingID, vs...)) +} + +// MappingIDGT applies the GT predicate on the "mapping_id" field. +func MappingIDGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldMappingID, v)) +} + +// MappingIDGTE applies the GTE predicate on the "mapping_id" field. +func MappingIDGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldMappingID, v)) +} + +// MappingIDLT applies the LT predicate on the "mapping_id" field. +func MappingIDLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldMappingID, v)) +} + +// MappingIDLTE applies the LTE predicate on the "mapping_id" field. +func MappingIDLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldMappingID, v)) +} + +// MappingIDContains applies the Contains predicate on the "mapping_id" field. +func MappingIDContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldMappingID, v)) +} + +// MappingIDHasPrefix applies the HasPrefix predicate on the "mapping_id" field. +func MappingIDHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldMappingID, v)) +} + +// MappingIDHasSuffix applies the HasSuffix predicate on the "mapping_id" field. +func MappingIDHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldMappingID, v)) +} + +// MappingIDEqualFold applies the EqualFold predicate on the "mapping_id" field. +func MappingIDEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldMappingID, v)) +} + +// MappingIDContainsFold applies the ContainsFold predicate on the "mapping_id" field. +func MappingIDContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldMappingID, v)) +} + +// TagsIsNil applies the IsNil predicate on the "tags" field. +func TagsIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldTags)) +} + +// TagsNotNil applies the NotNil predicate on the "tags" field. +func TagsNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldTags)) +} + +// DeletedAtEQ applies the EQ predicate on the "deleted_at" field. +func DeletedAtEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldDeletedAt, v)) +} + +// DeletedAtNEQ applies the NEQ predicate on the "deleted_at" field. +func DeletedAtNEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldDeletedAt, v)) +} + +// DeletedAtIn applies the In predicate on the "deleted_at" field. +func DeletedAtIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldDeletedAt, vs...)) +} + +// DeletedAtNotIn applies the NotIn predicate on the "deleted_at" field. +func DeletedAtNotIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldDeletedAt, vs...)) +} + +// DeletedAtGT applies the GT predicate on the "deleted_at" field. +func DeletedAtGT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldDeletedAt, v)) +} + +// DeletedAtGTE applies the GTE predicate on the "deleted_at" field. +func DeletedAtGTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldDeletedAt, v)) +} + +// DeletedAtLT applies the LT predicate on the "deleted_at" field. +func DeletedAtLT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldDeletedAt, v)) +} + +// DeletedAtLTE applies the LTE predicate on the "deleted_at" field. +func DeletedAtLTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldDeletedAt, v)) +} + +// DeletedAtIsNil applies the IsNil predicate on the "deleted_at" field. +func DeletedAtIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldDeletedAt)) +} + +// DeletedAtNotNil applies the NotNil predicate on the "deleted_at" field. +func DeletedAtNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldDeletedAt)) +} + +// DeletedByEQ applies the EQ predicate on the "deleted_by" field. +func DeletedByEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldDeletedBy, v)) +} + +// DeletedByNEQ applies the NEQ predicate on the "deleted_by" field. +func DeletedByNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldDeletedBy, v)) +} + +// DeletedByIn applies the In predicate on the "deleted_by" field. +func DeletedByIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldDeletedBy, vs...)) +} + +// DeletedByNotIn applies the NotIn predicate on the "deleted_by" field. +func DeletedByNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldDeletedBy, vs...)) +} + +// DeletedByGT applies the GT predicate on the "deleted_by" field. +func DeletedByGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldDeletedBy, v)) +} + +// DeletedByGTE applies the GTE predicate on the "deleted_by" field. +func DeletedByGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldDeletedBy, v)) +} + +// DeletedByLT applies the LT predicate on the "deleted_by" field. +func DeletedByLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldDeletedBy, v)) +} + +// DeletedByLTE applies the LTE predicate on the "deleted_by" field. +func DeletedByLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldDeletedBy, v)) +} + +// DeletedByContains applies the Contains predicate on the "deleted_by" field. +func DeletedByContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldDeletedBy, v)) +} + +// DeletedByHasPrefix applies the HasPrefix predicate on the "deleted_by" field. +func DeletedByHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldDeletedBy, v)) +} + +// DeletedByHasSuffix applies the HasSuffix predicate on the "deleted_by" field. +func DeletedByHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldDeletedBy, v)) +} + +// DeletedByIsNil applies the IsNil predicate on the "deleted_by" field. +func DeletedByIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldDeletedBy)) +} + +// DeletedByNotNil applies the NotNil predicate on the "deleted_by" field. +func DeletedByNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldDeletedBy)) +} + +// DeletedByEqualFold applies the EqualFold predicate on the "deleted_by" field. +func DeletedByEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldDeletedBy, v)) +} + +// DeletedByContainsFold applies the ContainsFold predicate on the "deleted_by" field. +func DeletedByContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldDeletedBy, v)) +} + +// OwnerIDEQ applies the EQ predicate on the "owner_id" field. +func OwnerIDEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldOwnerID, v)) +} + +// OwnerIDNEQ applies the NEQ predicate on the "owner_id" field. +func OwnerIDNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldOwnerID, v)) +} + +// OwnerIDIn applies the In predicate on the "owner_id" field. +func OwnerIDIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldOwnerID, vs...)) +} + +// OwnerIDNotIn applies the NotIn predicate on the "owner_id" field. +func OwnerIDNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldOwnerID, vs...)) +} + +// OwnerIDGT applies the GT predicate on the "owner_id" field. +func OwnerIDGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldOwnerID, v)) +} + +// OwnerIDGTE applies the GTE predicate on the "owner_id" field. +func OwnerIDGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldOwnerID, v)) +} + +// OwnerIDLT applies the LT predicate on the "owner_id" field. +func OwnerIDLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldOwnerID, v)) +} + +// OwnerIDLTE applies the LTE predicate on the "owner_id" field. +func OwnerIDLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldOwnerID, v)) +} + +// OwnerIDContains applies the Contains predicate on the "owner_id" field. +func OwnerIDContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldOwnerID, v)) +} + +// OwnerIDHasPrefix applies the HasPrefix predicate on the "owner_id" field. +func OwnerIDHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldOwnerID, v)) +} + +// OwnerIDHasSuffix applies the HasSuffix predicate on the "owner_id" field. +func OwnerIDHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldOwnerID, v)) +} + +// OwnerIDIsNil applies the IsNil predicate on the "owner_id" field. +func OwnerIDIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldOwnerID)) +} + +// OwnerIDNotNil applies the NotNil predicate on the "owner_id" field. +func OwnerIDNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldOwnerID)) +} + +// OwnerIDEqualFold applies the EqualFold predicate on the "owner_id" field. +func OwnerIDEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldOwnerID, v)) +} + +// OwnerIDContainsFold applies the ContainsFold predicate on the "owner_id" field. +func OwnerIDContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldOwnerID, v)) +} + +// StripeSubscriptionIDEQ applies the EQ predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDNEQ applies the NEQ predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDIn applies the In predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldStripeSubscriptionID, vs...)) +} + +// StripeSubscriptionIDNotIn applies the NotIn predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldStripeSubscriptionID, vs...)) +} + +// StripeSubscriptionIDGT applies the GT predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDGTE applies the GTE predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDLT applies the LT predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDLTE applies the LTE predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDContains applies the Contains predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDHasPrefix applies the HasPrefix predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDHasSuffix applies the HasSuffix predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDIsNil applies the IsNil predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldStripeSubscriptionID)) +} + +// StripeSubscriptionIDNotNil applies the NotNil predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldStripeSubscriptionID)) +} + +// StripeSubscriptionIDEqualFold applies the EqualFold predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldStripeSubscriptionID, v)) +} + +// StripeSubscriptionIDContainsFold applies the ContainsFold predicate on the "stripe_subscription_id" field. +func StripeSubscriptionIDContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldStripeSubscriptionID, v)) +} + +// ProductTierEQ applies the EQ predicate on the "product_tier" field. +func ProductTierEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldProductTier, v)) +} + +// ProductTierNEQ applies the NEQ predicate on the "product_tier" field. +func ProductTierNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldProductTier, v)) +} + +// ProductTierIn applies the In predicate on the "product_tier" field. +func ProductTierIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldProductTier, vs...)) +} + +// ProductTierNotIn applies the NotIn predicate on the "product_tier" field. +func ProductTierNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldProductTier, vs...)) +} + +// ProductTierGT applies the GT predicate on the "product_tier" field. +func ProductTierGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldProductTier, v)) +} + +// ProductTierGTE applies the GTE predicate on the "product_tier" field. +func ProductTierGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldProductTier, v)) +} + +// ProductTierLT applies the LT predicate on the "product_tier" field. +func ProductTierLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldProductTier, v)) +} + +// ProductTierLTE applies the LTE predicate on the "product_tier" field. +func ProductTierLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldProductTier, v)) +} + +// ProductTierContains applies the Contains predicate on the "product_tier" field. +func ProductTierContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldProductTier, v)) +} + +// ProductTierHasPrefix applies the HasPrefix predicate on the "product_tier" field. +func ProductTierHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldProductTier, v)) +} + +// ProductTierHasSuffix applies the HasSuffix predicate on the "product_tier" field. +func ProductTierHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldProductTier, v)) +} + +// ProductTierIsNil applies the IsNil predicate on the "product_tier" field. +func ProductTierIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldProductTier)) +} + +// ProductTierNotNil applies the NotNil predicate on the "product_tier" field. +func ProductTierNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldProductTier)) +} + +// ProductTierEqualFold applies the EqualFold predicate on the "product_tier" field. +func ProductTierEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldProductTier, v)) +} + +// ProductTierContainsFold applies the ContainsFold predicate on the "product_tier" field. +func ProductTierContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldProductTier, v)) +} + +// StripeProductTierIDEQ applies the EQ predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDNEQ applies the NEQ predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDIn applies the In predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldStripeProductTierID, vs...)) +} + +// StripeProductTierIDNotIn applies the NotIn predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldStripeProductTierID, vs...)) +} + +// StripeProductTierIDGT applies the GT predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDGTE applies the GTE predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDLT applies the LT predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDLTE applies the LTE predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDContains applies the Contains predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDHasPrefix applies the HasPrefix predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDHasSuffix applies the HasSuffix predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDIsNil applies the IsNil predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldStripeProductTierID)) +} + +// StripeProductTierIDNotNil applies the NotNil predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldStripeProductTierID)) +} + +// StripeProductTierIDEqualFold applies the EqualFold predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldStripeProductTierID, v)) +} + +// StripeProductTierIDContainsFold applies the ContainsFold predicate on the "stripe_product_tier_id" field. +func StripeProductTierIDContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldStripeProductTierID, v)) +} + +// StripeSubscriptionStatusEQ applies the EQ predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusNEQ applies the NEQ predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusIn applies the In predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldStripeSubscriptionStatus, vs...)) +} + +// StripeSubscriptionStatusNotIn applies the NotIn predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldStripeSubscriptionStatus, vs...)) +} + +// StripeSubscriptionStatusGT applies the GT predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusGTE applies the GTE predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusLT applies the LT predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusLTE applies the LTE predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusContains applies the Contains predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusHasPrefix applies the HasPrefix predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusHasSuffix applies the HasSuffix predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusIsNil applies the IsNil predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldStripeSubscriptionStatus)) +} + +// StripeSubscriptionStatusNotNil applies the NotNil predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldStripeSubscriptionStatus)) +} + +// StripeSubscriptionStatusEqualFold applies the EqualFold predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldStripeSubscriptionStatus, v)) +} + +// StripeSubscriptionStatusContainsFold applies the ContainsFold predicate on the "stripe_subscription_status" field. +func StripeSubscriptionStatusContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldStripeSubscriptionStatus, v)) +} + +// ActiveEQ applies the EQ predicate on the "active" field. +func ActiveEQ(v bool) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldActive, v)) +} + +// ActiveNEQ applies the NEQ predicate on the "active" field. +func ActiveNEQ(v bool) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldActive, v)) +} + +// StripeCustomerIDEQ applies the EQ predicate on the "stripe_customer_id" field. +func StripeCustomerIDEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDNEQ applies the NEQ predicate on the "stripe_customer_id" field. +func StripeCustomerIDNEQ(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDIn applies the In predicate on the "stripe_customer_id" field. +func StripeCustomerIDIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldStripeCustomerID, vs...)) +} + +// StripeCustomerIDNotIn applies the NotIn predicate on the "stripe_customer_id" field. +func StripeCustomerIDNotIn(vs ...string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldStripeCustomerID, vs...)) +} + +// StripeCustomerIDGT applies the GT predicate on the "stripe_customer_id" field. +func StripeCustomerIDGT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDGTE applies the GTE predicate on the "stripe_customer_id" field. +func StripeCustomerIDGTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDLT applies the LT predicate on the "stripe_customer_id" field. +func StripeCustomerIDLT(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDLTE applies the LTE predicate on the "stripe_customer_id" field. +func StripeCustomerIDLTE(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDContains applies the Contains predicate on the "stripe_customer_id" field. +func StripeCustomerIDContains(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContains(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDHasPrefix applies the HasPrefix predicate on the "stripe_customer_id" field. +func StripeCustomerIDHasPrefix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasPrefix(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDHasSuffix applies the HasSuffix predicate on the "stripe_customer_id" field. +func StripeCustomerIDHasSuffix(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldHasSuffix(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDIsNil applies the IsNil predicate on the "stripe_customer_id" field. +func StripeCustomerIDIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldStripeCustomerID)) +} + +// StripeCustomerIDNotNil applies the NotNil predicate on the "stripe_customer_id" field. +func StripeCustomerIDNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldStripeCustomerID)) +} + +// StripeCustomerIDEqualFold applies the EqualFold predicate on the "stripe_customer_id" field. +func StripeCustomerIDEqualFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEqualFold(FieldStripeCustomerID, v)) +} + +// StripeCustomerIDContainsFold applies the ContainsFold predicate on the "stripe_customer_id" field. +func StripeCustomerIDContainsFold(v string) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldContainsFold(FieldStripeCustomerID, v)) +} + +// ExpiresAtEQ applies the EQ predicate on the "expires_at" field. +func ExpiresAtEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldEQ(FieldExpiresAt, v)) +} + +// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field. +func ExpiresAtNEQ(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNEQ(FieldExpiresAt, v)) +} + +// ExpiresAtIn applies the In predicate on the "expires_at" field. +func ExpiresAtIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIn(FieldExpiresAt, vs...)) +} + +// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field. +func ExpiresAtNotIn(vs ...time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotIn(FieldExpiresAt, vs...)) +} + +// ExpiresAtGT applies the GT predicate on the "expires_at" field. +func ExpiresAtGT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGT(FieldExpiresAt, v)) +} + +// ExpiresAtGTE applies the GTE predicate on the "expires_at" field. +func ExpiresAtGTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldGTE(FieldExpiresAt, v)) +} + +// ExpiresAtLT applies the LT predicate on the "expires_at" field. +func ExpiresAtLT(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLT(FieldExpiresAt, v)) +} + +// ExpiresAtLTE applies the LTE predicate on the "expires_at" field. +func ExpiresAtLTE(v time.Time) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldLTE(FieldExpiresAt, v)) +} + +// ExpiresAtIsNil applies the IsNil predicate on the "expires_at" field. +func ExpiresAtIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldExpiresAt)) +} + +// ExpiresAtNotNil applies the NotNil predicate on the "expires_at" field. +func ExpiresAtNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldExpiresAt)) +} + +// FeaturesIsNil applies the IsNil predicate on the "features" field. +func FeaturesIsNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldIsNull(FieldFeatures)) +} + +// FeaturesNotNil applies the NotNil predicate on the "features" field. +func FeaturesNotNil() predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.FieldNotNull(FieldFeatures)) +} + +// And groups predicates with the AND operator between them. +func And(predicates ...predicate.OrgSubscriptionHistory) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.AndPredicates(predicates...)) +} + +// Or groups predicates with the OR operator between them. +func Or(predicates ...predicate.OrgSubscriptionHistory) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.OrPredicates(predicates...)) +} + +// Not applies the not operator on the given predicate. +func Not(p predicate.OrgSubscriptionHistory) predicate.OrgSubscriptionHistory { + return predicate.OrgSubscriptionHistory(sql.NotPredicates(p)) +} diff --git a/internal/ent/generated/orgsubscriptionhistory_create.go b/internal/ent/generated/orgsubscriptionhistory_create.go new file mode 100644 index 00000000..12257459 --- /dev/null +++ b/internal/ent/generated/orgsubscriptionhistory_create.go @@ -0,0 +1,579 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" + "github.com/theopenlane/entx/history" +) + +// OrgSubscriptionHistoryCreate is the builder for creating a OrgSubscriptionHistory entity. +type OrgSubscriptionHistoryCreate struct { + config + mutation *OrgSubscriptionHistoryMutation + hooks []Hook +} + +// SetHistoryTime sets the "history_time" field. +func (oshc *OrgSubscriptionHistoryCreate) SetHistoryTime(t time.Time) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetHistoryTime(t) + return oshc +} + +// SetNillableHistoryTime sets the "history_time" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableHistoryTime(t *time.Time) *OrgSubscriptionHistoryCreate { + if t != nil { + oshc.SetHistoryTime(*t) + } + return oshc +} + +// SetRef sets the "ref" field. +func (oshc *OrgSubscriptionHistoryCreate) SetRef(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetRef(s) + return oshc +} + +// SetNillableRef sets the "ref" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableRef(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetRef(*s) + } + return oshc +} + +// SetOperation sets the "operation" field. +func (oshc *OrgSubscriptionHistoryCreate) SetOperation(ht history.OpType) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetOperation(ht) + return oshc +} + +// SetCreatedAt sets the "created_at" field. +func (oshc *OrgSubscriptionHistoryCreate) SetCreatedAt(t time.Time) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetCreatedAt(t) + return oshc +} + +// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableCreatedAt(t *time.Time) *OrgSubscriptionHistoryCreate { + if t != nil { + oshc.SetCreatedAt(*t) + } + return oshc +} + +// SetUpdatedAt sets the "updated_at" field. +func (oshc *OrgSubscriptionHistoryCreate) SetUpdatedAt(t time.Time) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetUpdatedAt(t) + return oshc +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableUpdatedAt(t *time.Time) *OrgSubscriptionHistoryCreate { + if t != nil { + oshc.SetUpdatedAt(*t) + } + return oshc +} + +// SetCreatedBy sets the "created_by" field. +func (oshc *OrgSubscriptionHistoryCreate) SetCreatedBy(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetCreatedBy(s) + return oshc +} + +// SetNillableCreatedBy sets the "created_by" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableCreatedBy(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetCreatedBy(*s) + } + return oshc +} + +// SetUpdatedBy sets the "updated_by" field. +func (oshc *OrgSubscriptionHistoryCreate) SetUpdatedBy(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetUpdatedBy(s) + return oshc +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableUpdatedBy(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetUpdatedBy(*s) + } + return oshc +} + +// SetMappingID sets the "mapping_id" field. +func (oshc *OrgSubscriptionHistoryCreate) SetMappingID(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetMappingID(s) + return oshc +} + +// SetNillableMappingID sets the "mapping_id" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableMappingID(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetMappingID(*s) + } + return oshc +} + +// SetTags sets the "tags" field. +func (oshc *OrgSubscriptionHistoryCreate) SetTags(s []string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetTags(s) + return oshc +} + +// SetDeletedAt sets the "deleted_at" field. +func (oshc *OrgSubscriptionHistoryCreate) SetDeletedAt(t time.Time) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetDeletedAt(t) + return oshc +} + +// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableDeletedAt(t *time.Time) *OrgSubscriptionHistoryCreate { + if t != nil { + oshc.SetDeletedAt(*t) + } + return oshc +} + +// SetDeletedBy sets the "deleted_by" field. +func (oshc *OrgSubscriptionHistoryCreate) SetDeletedBy(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetDeletedBy(s) + return oshc +} + +// SetNillableDeletedBy sets the "deleted_by" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableDeletedBy(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetDeletedBy(*s) + } + return oshc +} + +// SetOwnerID sets the "owner_id" field. +func (oshc *OrgSubscriptionHistoryCreate) SetOwnerID(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetOwnerID(s) + return oshc +} + +// SetNillableOwnerID sets the "owner_id" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableOwnerID(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetOwnerID(*s) + } + return oshc +} + +// SetStripeSubscriptionID sets the "stripe_subscription_id" field. +func (oshc *OrgSubscriptionHistoryCreate) SetStripeSubscriptionID(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetStripeSubscriptionID(s) + return oshc +} + +// SetNillableStripeSubscriptionID sets the "stripe_subscription_id" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableStripeSubscriptionID(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetStripeSubscriptionID(*s) + } + return oshc +} + +// SetProductTier sets the "product_tier" field. +func (oshc *OrgSubscriptionHistoryCreate) SetProductTier(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetProductTier(s) + return oshc +} + +// SetNillableProductTier sets the "product_tier" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableProductTier(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetProductTier(*s) + } + return oshc +} + +// SetStripeProductTierID sets the "stripe_product_tier_id" field. +func (oshc *OrgSubscriptionHistoryCreate) SetStripeProductTierID(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetStripeProductTierID(s) + return oshc +} + +// SetNillableStripeProductTierID sets the "stripe_product_tier_id" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableStripeProductTierID(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetStripeProductTierID(*s) + } + return oshc +} + +// SetStripeSubscriptionStatus sets the "stripe_subscription_status" field. +func (oshc *OrgSubscriptionHistoryCreate) SetStripeSubscriptionStatus(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetStripeSubscriptionStatus(s) + return oshc +} + +// SetNillableStripeSubscriptionStatus sets the "stripe_subscription_status" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableStripeSubscriptionStatus(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetStripeSubscriptionStatus(*s) + } + return oshc +} + +// SetActive sets the "active" field. +func (oshc *OrgSubscriptionHistoryCreate) SetActive(b bool) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetActive(b) + return oshc +} + +// SetNillableActive sets the "active" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableActive(b *bool) *OrgSubscriptionHistoryCreate { + if b != nil { + oshc.SetActive(*b) + } + return oshc +} + +// SetStripeCustomerID sets the "stripe_customer_id" field. +func (oshc *OrgSubscriptionHistoryCreate) SetStripeCustomerID(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetStripeCustomerID(s) + return oshc +} + +// SetNillableStripeCustomerID sets the "stripe_customer_id" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableStripeCustomerID(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetStripeCustomerID(*s) + } + return oshc +} + +// SetExpiresAt sets the "expires_at" field. +func (oshc *OrgSubscriptionHistoryCreate) SetExpiresAt(t time.Time) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetExpiresAt(t) + return oshc +} + +// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableExpiresAt(t *time.Time) *OrgSubscriptionHistoryCreate { + if t != nil { + oshc.SetExpiresAt(*t) + } + return oshc +} + +// SetFeatures sets the "features" field. +func (oshc *OrgSubscriptionHistoryCreate) SetFeatures(s []string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetFeatures(s) + return oshc +} + +// SetID sets the "id" field. +func (oshc *OrgSubscriptionHistoryCreate) SetID(s string) *OrgSubscriptionHistoryCreate { + oshc.mutation.SetID(s) + return oshc +} + +// SetNillableID sets the "id" field if the given value is not nil. +func (oshc *OrgSubscriptionHistoryCreate) SetNillableID(s *string) *OrgSubscriptionHistoryCreate { + if s != nil { + oshc.SetID(*s) + } + return oshc +} + +// Mutation returns the OrgSubscriptionHistoryMutation object of the builder. +func (oshc *OrgSubscriptionHistoryCreate) Mutation() *OrgSubscriptionHistoryMutation { + return oshc.mutation +} + +// Save creates the OrgSubscriptionHistory in the database. +func (oshc *OrgSubscriptionHistoryCreate) Save(ctx context.Context) (*OrgSubscriptionHistory, error) { + oshc.defaults() + return withHooks(ctx, oshc.sqlSave, oshc.mutation, oshc.hooks) +} + +// SaveX calls Save and panics if Save returns an error. +func (oshc *OrgSubscriptionHistoryCreate) SaveX(ctx context.Context) *OrgSubscriptionHistory { + v, err := oshc.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (oshc *OrgSubscriptionHistoryCreate) Exec(ctx context.Context) error { + _, err := oshc.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (oshc *OrgSubscriptionHistoryCreate) ExecX(ctx context.Context) { + if err := oshc.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (oshc *OrgSubscriptionHistoryCreate) defaults() { + if _, ok := oshc.mutation.HistoryTime(); !ok { + v := orgsubscriptionhistory.DefaultHistoryTime() + oshc.mutation.SetHistoryTime(v) + } + if _, ok := oshc.mutation.CreatedAt(); !ok { + v := orgsubscriptionhistory.DefaultCreatedAt() + oshc.mutation.SetCreatedAt(v) + } + if _, ok := oshc.mutation.UpdatedAt(); !ok { + v := orgsubscriptionhistory.DefaultUpdatedAt() + oshc.mutation.SetUpdatedAt(v) + } + if _, ok := oshc.mutation.MappingID(); !ok { + v := orgsubscriptionhistory.DefaultMappingID() + oshc.mutation.SetMappingID(v) + } + if _, ok := oshc.mutation.Tags(); !ok { + v := orgsubscriptionhistory.DefaultTags + oshc.mutation.SetTags(v) + } + if _, ok := oshc.mutation.Active(); !ok { + v := orgsubscriptionhistory.DefaultActive + oshc.mutation.SetActive(v) + } + if _, ok := oshc.mutation.ID(); !ok { + v := orgsubscriptionhistory.DefaultID() + oshc.mutation.SetID(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (oshc *OrgSubscriptionHistoryCreate) check() error { + if _, ok := oshc.mutation.HistoryTime(); !ok { + return &ValidationError{Name: "history_time", err: errors.New(`generated: missing required field "OrgSubscriptionHistory.history_time"`)} + } + if _, ok := oshc.mutation.Operation(); !ok { + return &ValidationError{Name: "operation", err: errors.New(`generated: missing required field "OrgSubscriptionHistory.operation"`)} + } + if v, ok := oshc.mutation.Operation(); ok { + if err := orgsubscriptionhistory.OperationValidator(v); err != nil { + return &ValidationError{Name: "operation", err: fmt.Errorf(`generated: validator failed for field "OrgSubscriptionHistory.operation": %w`, err)} + } + } + if _, ok := oshc.mutation.MappingID(); !ok { + return &ValidationError{Name: "mapping_id", err: errors.New(`generated: missing required field "OrgSubscriptionHistory.mapping_id"`)} + } + if _, ok := oshc.mutation.Active(); !ok { + return &ValidationError{Name: "active", err: errors.New(`generated: missing required field "OrgSubscriptionHistory.active"`)} + } + return nil +} + +func (oshc *OrgSubscriptionHistoryCreate) sqlSave(ctx context.Context) (*OrgSubscriptionHistory, error) { + if err := oshc.check(); err != nil { + return nil, err + } + _node, _spec := oshc.createSpec() + if err := sqlgraph.CreateNode(ctx, oshc.driver, _spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + if _spec.ID.Value != nil { + if id, ok := _spec.ID.Value.(string); ok { + _node.ID = id + } else { + return nil, fmt.Errorf("unexpected OrgSubscriptionHistory.ID type: %T", _spec.ID.Value) + } + } + oshc.mutation.id = &_node.ID + oshc.mutation.done = true + return _node, nil +} + +func (oshc *OrgSubscriptionHistoryCreate) createSpec() (*OrgSubscriptionHistory, *sqlgraph.CreateSpec) { + var ( + _node = &OrgSubscriptionHistory{config: oshc.config} + _spec = sqlgraph.NewCreateSpec(orgsubscriptionhistory.Table, sqlgraph.NewFieldSpec(orgsubscriptionhistory.FieldID, field.TypeString)) + ) + _spec.Schema = oshc.schemaConfig.OrgSubscriptionHistory + if id, ok := oshc.mutation.ID(); ok { + _node.ID = id + _spec.ID.Value = id + } + if value, ok := oshc.mutation.HistoryTime(); ok { + _spec.SetField(orgsubscriptionhistory.FieldHistoryTime, field.TypeTime, value) + _node.HistoryTime = value + } + if value, ok := oshc.mutation.Ref(); ok { + _spec.SetField(orgsubscriptionhistory.FieldRef, field.TypeString, value) + _node.Ref = value + } + if value, ok := oshc.mutation.Operation(); ok { + _spec.SetField(orgsubscriptionhistory.FieldOperation, field.TypeEnum, value) + _node.Operation = value + } + if value, ok := oshc.mutation.CreatedAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldCreatedAt, field.TypeTime, value) + _node.CreatedAt = value + } + if value, ok := oshc.mutation.UpdatedAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldUpdatedAt, field.TypeTime, value) + _node.UpdatedAt = value + } + if value, ok := oshc.mutation.CreatedBy(); ok { + _spec.SetField(orgsubscriptionhistory.FieldCreatedBy, field.TypeString, value) + _node.CreatedBy = value + } + if value, ok := oshc.mutation.UpdatedBy(); ok { + _spec.SetField(orgsubscriptionhistory.FieldUpdatedBy, field.TypeString, value) + _node.UpdatedBy = value + } + if value, ok := oshc.mutation.MappingID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldMappingID, field.TypeString, value) + _node.MappingID = value + } + if value, ok := oshc.mutation.Tags(); ok { + _spec.SetField(orgsubscriptionhistory.FieldTags, field.TypeJSON, value) + _node.Tags = value + } + if value, ok := oshc.mutation.DeletedAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldDeletedAt, field.TypeTime, value) + _node.DeletedAt = value + } + if value, ok := oshc.mutation.DeletedBy(); ok { + _spec.SetField(orgsubscriptionhistory.FieldDeletedBy, field.TypeString, value) + _node.DeletedBy = value + } + if value, ok := oshc.mutation.OwnerID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldOwnerID, field.TypeString, value) + _node.OwnerID = value + } + if value, ok := oshc.mutation.StripeSubscriptionID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeSubscriptionID, field.TypeString, value) + _node.StripeSubscriptionID = value + } + if value, ok := oshc.mutation.ProductTier(); ok { + _spec.SetField(orgsubscriptionhistory.FieldProductTier, field.TypeString, value) + _node.ProductTier = value + } + if value, ok := oshc.mutation.StripeProductTierID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeProductTierID, field.TypeString, value) + _node.StripeProductTierID = value + } + if value, ok := oshc.mutation.StripeSubscriptionStatus(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeSubscriptionStatus, field.TypeString, value) + _node.StripeSubscriptionStatus = value + } + if value, ok := oshc.mutation.Active(); ok { + _spec.SetField(orgsubscriptionhistory.FieldActive, field.TypeBool, value) + _node.Active = value + } + if value, ok := oshc.mutation.StripeCustomerID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeCustomerID, field.TypeString, value) + _node.StripeCustomerID = value + } + if value, ok := oshc.mutation.ExpiresAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldExpiresAt, field.TypeTime, value) + _node.ExpiresAt = &value + } + if value, ok := oshc.mutation.Features(); ok { + _spec.SetField(orgsubscriptionhistory.FieldFeatures, field.TypeJSON, value) + _node.Features = value + } + return _node, _spec +} + +// OrgSubscriptionHistoryCreateBulk is the builder for creating many OrgSubscriptionHistory entities in bulk. +type OrgSubscriptionHistoryCreateBulk struct { + config + err error + builders []*OrgSubscriptionHistoryCreate +} + +// Save creates the OrgSubscriptionHistory entities in the database. +func (oshcb *OrgSubscriptionHistoryCreateBulk) Save(ctx context.Context) ([]*OrgSubscriptionHistory, error) { + if oshcb.err != nil { + return nil, oshcb.err + } + specs := make([]*sqlgraph.CreateSpec, len(oshcb.builders)) + nodes := make([]*OrgSubscriptionHistory, len(oshcb.builders)) + mutators := make([]Mutator, len(oshcb.builders)) + for i := range oshcb.builders { + func(i int, root context.Context) { + builder := oshcb.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*OrgSubscriptionHistoryMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + var err error + nodes[i], specs[i] = builder.createSpec() + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, oshcb.builders[i+1].mutation) + } else { + spec := &sqlgraph.BatchCreateSpec{Nodes: specs} + // Invoke the actual operation on the latest mutation in the chain. + if err = sqlgraph.BatchCreate(ctx, oshcb.driver, spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + } + } + if err != nil { + return nil, err + } + mutation.id = &nodes[i].ID + mutation.done = true + return nodes[i], nil + }) + for i := len(builder.hooks) - 1; i >= 0; i-- { + mut = builder.hooks[i](mut) + } + mutators[i] = mut + }(i, ctx) + } + if len(mutators) > 0 { + if _, err := mutators[0].Mutate(ctx, oshcb.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (oshcb *OrgSubscriptionHistoryCreateBulk) SaveX(ctx context.Context) []*OrgSubscriptionHistory { + v, err := oshcb.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (oshcb *OrgSubscriptionHistoryCreateBulk) Exec(ctx context.Context) error { + _, err := oshcb.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (oshcb *OrgSubscriptionHistoryCreateBulk) ExecX(ctx context.Context) { + if err := oshcb.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/internal/ent/generated/orgsubscriptionhistory_delete.go b/internal/ent/generated/orgsubscriptionhistory_delete.go new file mode 100644 index 00000000..719b4970 --- /dev/null +++ b/internal/ent/generated/orgsubscriptionhistory_delete.go @@ -0,0 +1,92 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "context" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/theopenlane/core/internal/ent/generated/predicate" + + "github.com/theopenlane/core/internal/ent/generated/internal" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" +) + +// OrgSubscriptionHistoryDelete is the builder for deleting a OrgSubscriptionHistory entity. +type OrgSubscriptionHistoryDelete struct { + config + hooks []Hook + mutation *OrgSubscriptionHistoryMutation +} + +// Where appends a list predicates to the OrgSubscriptionHistoryDelete builder. +func (oshd *OrgSubscriptionHistoryDelete) Where(ps ...predicate.OrgSubscriptionHistory) *OrgSubscriptionHistoryDelete { + oshd.mutation.Where(ps...) + return oshd +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (oshd *OrgSubscriptionHistoryDelete) Exec(ctx context.Context) (int, error) { + return withHooks(ctx, oshd.sqlExec, oshd.mutation, oshd.hooks) +} + +// ExecX is like Exec, but panics if an error occurs. +func (oshd *OrgSubscriptionHistoryDelete) ExecX(ctx context.Context) int { + n, err := oshd.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +func (oshd *OrgSubscriptionHistoryDelete) sqlExec(ctx context.Context) (int, error) { + _spec := sqlgraph.NewDeleteSpec(orgsubscriptionhistory.Table, sqlgraph.NewFieldSpec(orgsubscriptionhistory.FieldID, field.TypeString)) + _spec.Node.Schema = oshd.schemaConfig.OrgSubscriptionHistory + ctx = internal.NewSchemaConfigContext(ctx, oshd.schemaConfig) + if ps := oshd.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, oshd.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + oshd.mutation.done = true + return affected, err +} + +// OrgSubscriptionHistoryDeleteOne is the builder for deleting a single OrgSubscriptionHistory entity. +type OrgSubscriptionHistoryDeleteOne struct { + oshd *OrgSubscriptionHistoryDelete +} + +// Where appends a list predicates to the OrgSubscriptionHistoryDelete builder. +func (oshdo *OrgSubscriptionHistoryDeleteOne) Where(ps ...predicate.OrgSubscriptionHistory) *OrgSubscriptionHistoryDeleteOne { + oshdo.oshd.mutation.Where(ps...) + return oshdo +} + +// Exec executes the deletion query. +func (oshdo *OrgSubscriptionHistoryDeleteOne) Exec(ctx context.Context) error { + n, err := oshdo.oshd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{orgsubscriptionhistory.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (oshdo *OrgSubscriptionHistoryDeleteOne) ExecX(ctx context.Context) { + if err := oshdo.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/internal/ent/generated/orgsubscriptionhistory_query.go b/internal/ent/generated/orgsubscriptionhistory_query.go new file mode 100644 index 00000000..6093e67d --- /dev/null +++ b/internal/ent/generated/orgsubscriptionhistory_query.go @@ -0,0 +1,565 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "context" + "fmt" + "math" + + "entgo.io/ent" + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" + "github.com/theopenlane/core/internal/ent/generated/predicate" + + "github.com/theopenlane/core/internal/ent/generated/internal" +) + +// OrgSubscriptionHistoryQuery is the builder for querying OrgSubscriptionHistory entities. +type OrgSubscriptionHistoryQuery struct { + config + ctx *QueryContext + order []orgsubscriptionhistory.OrderOption + inters []Interceptor + predicates []predicate.OrgSubscriptionHistory + loadTotal []func(context.Context, []*OrgSubscriptionHistory) error + modifiers []func(*sql.Selector) + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Where adds a new predicate for the OrgSubscriptionHistoryQuery builder. +func (oshq *OrgSubscriptionHistoryQuery) Where(ps ...predicate.OrgSubscriptionHistory) *OrgSubscriptionHistoryQuery { + oshq.predicates = append(oshq.predicates, ps...) + return oshq +} + +// Limit the number of records to be returned by this query. +func (oshq *OrgSubscriptionHistoryQuery) Limit(limit int) *OrgSubscriptionHistoryQuery { + oshq.ctx.Limit = &limit + return oshq +} + +// Offset to start from. +func (oshq *OrgSubscriptionHistoryQuery) Offset(offset int) *OrgSubscriptionHistoryQuery { + oshq.ctx.Offset = &offset + return oshq +} + +// Unique configures the query builder to filter duplicate records on query. +// By default, unique is set to true, and can be disabled using this method. +func (oshq *OrgSubscriptionHistoryQuery) Unique(unique bool) *OrgSubscriptionHistoryQuery { + oshq.ctx.Unique = &unique + return oshq +} + +// Order specifies how the records should be ordered. +func (oshq *OrgSubscriptionHistoryQuery) Order(o ...orgsubscriptionhistory.OrderOption) *OrgSubscriptionHistoryQuery { + oshq.order = append(oshq.order, o...) + return oshq +} + +// First returns the first OrgSubscriptionHistory entity from the query. +// Returns a *NotFoundError when no OrgSubscriptionHistory was found. +func (oshq *OrgSubscriptionHistoryQuery) First(ctx context.Context) (*OrgSubscriptionHistory, error) { + nodes, err := oshq.Limit(1).All(setContextOp(ctx, oshq.ctx, ent.OpQueryFirst)) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{orgsubscriptionhistory.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (oshq *OrgSubscriptionHistoryQuery) FirstX(ctx context.Context) *OrgSubscriptionHistory { + node, err := oshq.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first OrgSubscriptionHistory ID from the query. +// Returns a *NotFoundError when no OrgSubscriptionHistory ID was found. +func (oshq *OrgSubscriptionHistoryQuery) FirstID(ctx context.Context) (id string, err error) { + var ids []string + if ids, err = oshq.Limit(1).IDs(setContextOp(ctx, oshq.ctx, ent.OpQueryFirstID)); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{orgsubscriptionhistory.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (oshq *OrgSubscriptionHistoryQuery) FirstIDX(ctx context.Context) string { + id, err := oshq.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single OrgSubscriptionHistory entity found by the query, ensuring it only returns one. +// Returns a *NotSingularError when more than one OrgSubscriptionHistory entity is found. +// Returns a *NotFoundError when no OrgSubscriptionHistory entities are found. +func (oshq *OrgSubscriptionHistoryQuery) Only(ctx context.Context) (*OrgSubscriptionHistory, error) { + nodes, err := oshq.Limit(2).All(setContextOp(ctx, oshq.ctx, ent.OpQueryOnly)) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{orgsubscriptionhistory.Label} + default: + return nil, &NotSingularError{orgsubscriptionhistory.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (oshq *OrgSubscriptionHistoryQuery) OnlyX(ctx context.Context) *OrgSubscriptionHistory { + node, err := oshq.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only OrgSubscriptionHistory ID in the query. +// Returns a *NotSingularError when more than one OrgSubscriptionHistory ID is found. +// Returns a *NotFoundError when no entities are found. +func (oshq *OrgSubscriptionHistoryQuery) OnlyID(ctx context.Context) (id string, err error) { + var ids []string + if ids, err = oshq.Limit(2).IDs(setContextOp(ctx, oshq.ctx, ent.OpQueryOnlyID)); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{orgsubscriptionhistory.Label} + default: + err = &NotSingularError{orgsubscriptionhistory.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (oshq *OrgSubscriptionHistoryQuery) OnlyIDX(ctx context.Context) string { + id, err := oshq.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of OrgSubscriptionHistories. +func (oshq *OrgSubscriptionHistoryQuery) All(ctx context.Context) ([]*OrgSubscriptionHistory, error) { + ctx = setContextOp(ctx, oshq.ctx, ent.OpQueryAll) + if err := oshq.prepareQuery(ctx); err != nil { + return nil, err + } + qr := querierAll[[]*OrgSubscriptionHistory, *OrgSubscriptionHistoryQuery]() + return withInterceptors[[]*OrgSubscriptionHistory](ctx, oshq, qr, oshq.inters) +} + +// AllX is like All, but panics if an error occurs. +func (oshq *OrgSubscriptionHistoryQuery) AllX(ctx context.Context) []*OrgSubscriptionHistory { + nodes, err := oshq.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// IDs executes the query and returns a list of OrgSubscriptionHistory IDs. +func (oshq *OrgSubscriptionHistoryQuery) IDs(ctx context.Context) (ids []string, err error) { + if oshq.ctx.Unique == nil && oshq.path != nil { + oshq.Unique(true) + } + ctx = setContextOp(ctx, oshq.ctx, ent.OpQueryIDs) + if err = oshq.Select(orgsubscriptionhistory.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (oshq *OrgSubscriptionHistoryQuery) IDsX(ctx context.Context) []string { + ids, err := oshq.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (oshq *OrgSubscriptionHistoryQuery) Count(ctx context.Context) (int, error) { + ctx = setContextOp(ctx, oshq.ctx, ent.OpQueryCount) + if err := oshq.prepareQuery(ctx); err != nil { + return 0, err + } + return withInterceptors[int](ctx, oshq, querierCount[*OrgSubscriptionHistoryQuery](), oshq.inters) +} + +// CountX is like Count, but panics if an error occurs. +func (oshq *OrgSubscriptionHistoryQuery) CountX(ctx context.Context) int { + count, err := oshq.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (oshq *OrgSubscriptionHistoryQuery) Exist(ctx context.Context) (bool, error) { + ctx = setContextOp(ctx, oshq.ctx, ent.OpQueryExist) + switch _, err := oshq.FirstID(ctx); { + case IsNotFound(err): + return false, nil + case err != nil: + return false, fmt.Errorf("generated: check existence: %w", err) + default: + return true, nil + } +} + +// ExistX is like Exist, but panics if an error occurs. +func (oshq *OrgSubscriptionHistoryQuery) ExistX(ctx context.Context) bool { + exist, err := oshq.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the OrgSubscriptionHistoryQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (oshq *OrgSubscriptionHistoryQuery) Clone() *OrgSubscriptionHistoryQuery { + if oshq == nil { + return nil + } + return &OrgSubscriptionHistoryQuery{ + config: oshq.config, + ctx: oshq.ctx.Clone(), + order: append([]orgsubscriptionhistory.OrderOption{}, oshq.order...), + inters: append([]Interceptor{}, oshq.inters...), + predicates: append([]predicate.OrgSubscriptionHistory{}, oshq.predicates...), + // clone intermediate query. + sql: oshq.sql.Clone(), + path: oshq.path, + modifiers: append([]func(*sql.Selector){}, oshq.modifiers...), + } +} + +// GroupBy is used to group vertices by one or more fields/columns. +// It is often used with aggregate functions, like: count, max, mean, min, sum. +// +// Example: +// +// var v []struct { +// HistoryTime time.Time `json:"history_time,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.OrgSubscriptionHistory.Query(). +// GroupBy(orgsubscriptionhistory.FieldHistoryTime). +// Aggregate(generated.Count()). +// Scan(ctx, &v) +func (oshq *OrgSubscriptionHistoryQuery) GroupBy(field string, fields ...string) *OrgSubscriptionHistoryGroupBy { + oshq.ctx.Fields = append([]string{field}, fields...) + grbuild := &OrgSubscriptionHistoryGroupBy{build: oshq} + grbuild.flds = &oshq.ctx.Fields + grbuild.label = orgsubscriptionhistory.Label + grbuild.scan = grbuild.Scan + return grbuild +} + +// Select allows the selection one or more fields/columns for the given query, +// instead of selecting all fields in the entity. +// +// Example: +// +// var v []struct { +// HistoryTime time.Time `json:"history_time,omitempty"` +// } +// +// client.OrgSubscriptionHistory.Query(). +// Select(orgsubscriptionhistory.FieldHistoryTime). +// Scan(ctx, &v) +func (oshq *OrgSubscriptionHistoryQuery) Select(fields ...string) *OrgSubscriptionHistorySelect { + oshq.ctx.Fields = append(oshq.ctx.Fields, fields...) + sbuild := &OrgSubscriptionHistorySelect{OrgSubscriptionHistoryQuery: oshq} + sbuild.label = orgsubscriptionhistory.Label + sbuild.flds, sbuild.scan = &oshq.ctx.Fields, sbuild.Scan + return sbuild +} + +// Aggregate returns a OrgSubscriptionHistorySelect configured with the given aggregations. +func (oshq *OrgSubscriptionHistoryQuery) Aggregate(fns ...AggregateFunc) *OrgSubscriptionHistorySelect { + return oshq.Select().Aggregate(fns...) +} + +func (oshq *OrgSubscriptionHistoryQuery) prepareQuery(ctx context.Context) error { + for _, inter := range oshq.inters { + if inter == nil { + return fmt.Errorf("generated: uninitialized interceptor (forgotten import generated/runtime?)") + } + if trv, ok := inter.(Traverser); ok { + if err := trv.Traverse(ctx, oshq); err != nil { + return err + } + } + } + for _, f := range oshq.ctx.Fields { + if !orgsubscriptionhistory.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("generated: invalid field %q for query", f)} + } + } + if oshq.path != nil { + prev, err := oshq.path(ctx) + if err != nil { + return err + } + oshq.sql = prev + } + return nil +} + +func (oshq *OrgSubscriptionHistoryQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*OrgSubscriptionHistory, error) { + var ( + nodes = []*OrgSubscriptionHistory{} + _spec = oshq.querySpec() + ) + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*OrgSubscriptionHistory).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &OrgSubscriptionHistory{config: oshq.config} + nodes = append(nodes, node) + return node.assignValues(columns, values) + } + _spec.Node.Schema = oshq.schemaConfig.OrgSubscriptionHistory + ctx = internal.NewSchemaConfigContext(ctx, oshq.schemaConfig) + if len(oshq.modifiers) > 0 { + _spec.Modifiers = oshq.modifiers + } + for i := range hooks { + hooks[i](ctx, _spec) + } + if err := sqlgraph.QueryNodes(ctx, oshq.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + for i := range oshq.loadTotal { + if err := oshq.loadTotal[i](ctx, nodes); err != nil { + return nil, err + } + } + return nodes, nil +} + +func (oshq *OrgSubscriptionHistoryQuery) sqlCount(ctx context.Context) (int, error) { + _spec := oshq.querySpec() + _spec.Node.Schema = oshq.schemaConfig.OrgSubscriptionHistory + ctx = internal.NewSchemaConfigContext(ctx, oshq.schemaConfig) + if len(oshq.modifiers) > 0 { + _spec.Modifiers = oshq.modifiers + } + _spec.Node.Columns = oshq.ctx.Fields + if len(oshq.ctx.Fields) > 0 { + _spec.Unique = oshq.ctx.Unique != nil && *oshq.ctx.Unique + } + return sqlgraph.CountNodes(ctx, oshq.driver, _spec) +} + +func (oshq *OrgSubscriptionHistoryQuery) querySpec() *sqlgraph.QuerySpec { + _spec := sqlgraph.NewQuerySpec(orgsubscriptionhistory.Table, orgsubscriptionhistory.Columns, sqlgraph.NewFieldSpec(orgsubscriptionhistory.FieldID, field.TypeString)) + _spec.From = oshq.sql + if unique := oshq.ctx.Unique; unique != nil { + _spec.Unique = *unique + } else if oshq.path != nil { + _spec.Unique = true + } + if fields := oshq.ctx.Fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, orgsubscriptionhistory.FieldID) + for i := range fields { + if fields[i] != orgsubscriptionhistory.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + } + if ps := oshq.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := oshq.ctx.Limit; limit != nil { + _spec.Limit = *limit + } + if offset := oshq.ctx.Offset; offset != nil { + _spec.Offset = *offset + } + if ps := oshq.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (oshq *OrgSubscriptionHistoryQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(oshq.driver.Dialect()) + t1 := builder.Table(orgsubscriptionhistory.Table) + columns := oshq.ctx.Fields + if len(columns) == 0 { + columns = orgsubscriptionhistory.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if oshq.sql != nil { + selector = oshq.sql + selector.Select(selector.Columns(columns...)...) + } + if oshq.ctx.Unique != nil && *oshq.ctx.Unique { + selector.Distinct() + } + t1.Schema(oshq.schemaConfig.OrgSubscriptionHistory) + ctx = internal.NewSchemaConfigContext(ctx, oshq.schemaConfig) + selector.WithContext(ctx) + for _, m := range oshq.modifiers { + m(selector) + } + for _, p := range oshq.predicates { + p(selector) + } + for _, p := range oshq.order { + p(selector) + } + if offset := oshq.ctx.Offset; offset != nil { + // limit is mandatory for offset clause. We start + // with default value, and override it below if needed. + selector.Offset(*offset).Limit(math.MaxInt32) + } + if limit := oshq.ctx.Limit; limit != nil { + selector.Limit(*limit) + } + return selector +} + +// Modify adds a query modifier for attaching custom logic to queries. +func (oshq *OrgSubscriptionHistoryQuery) Modify(modifiers ...func(s *sql.Selector)) *OrgSubscriptionHistorySelect { + oshq.modifiers = append(oshq.modifiers, modifiers...) + return oshq.Select() +} + +// OrgSubscriptionHistoryGroupBy is the group-by builder for OrgSubscriptionHistory entities. +type OrgSubscriptionHistoryGroupBy struct { + selector + build *OrgSubscriptionHistoryQuery +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (oshgb *OrgSubscriptionHistoryGroupBy) Aggregate(fns ...AggregateFunc) *OrgSubscriptionHistoryGroupBy { + oshgb.fns = append(oshgb.fns, fns...) + return oshgb +} + +// Scan applies the selector query and scans the result into the given value. +func (oshgb *OrgSubscriptionHistoryGroupBy) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, oshgb.build.ctx, ent.OpQueryGroupBy) + if err := oshgb.build.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*OrgSubscriptionHistoryQuery, *OrgSubscriptionHistoryGroupBy](ctx, oshgb.build, oshgb, oshgb.build.inters, v) +} + +func (oshgb *OrgSubscriptionHistoryGroupBy) sqlScan(ctx context.Context, root *OrgSubscriptionHistoryQuery, v any) error { + selector := root.sqlQuery(ctx).Select() + aggregation := make([]string, 0, len(oshgb.fns)) + for _, fn := range oshgb.fns { + aggregation = append(aggregation, fn(selector)) + } + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(*oshgb.flds)+len(oshgb.fns)) + for _, f := range *oshgb.flds { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + selector.GroupBy(selector.Columns(*oshgb.flds...)...) + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := oshgb.build.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// OrgSubscriptionHistorySelect is the builder for selecting fields of OrgSubscriptionHistory entities. +type OrgSubscriptionHistorySelect struct { + *OrgSubscriptionHistoryQuery + selector +} + +// Aggregate adds the given aggregation functions to the selector query. +func (oshs *OrgSubscriptionHistorySelect) Aggregate(fns ...AggregateFunc) *OrgSubscriptionHistorySelect { + oshs.fns = append(oshs.fns, fns...) + return oshs +} + +// Scan applies the selector query and scans the result into the given value. +func (oshs *OrgSubscriptionHistorySelect) Scan(ctx context.Context, v any) error { + ctx = setContextOp(ctx, oshs.ctx, ent.OpQuerySelect) + if err := oshs.prepareQuery(ctx); err != nil { + return err + } + return scanWithInterceptors[*OrgSubscriptionHistoryQuery, *OrgSubscriptionHistorySelect](ctx, oshs.OrgSubscriptionHistoryQuery, oshs, oshs.inters, v) +} + +func (oshs *OrgSubscriptionHistorySelect) sqlScan(ctx context.Context, root *OrgSubscriptionHistoryQuery, v any) error { + selector := root.sqlQuery(ctx) + aggregation := make([]string, 0, len(oshs.fns)) + for _, fn := range oshs.fns { + aggregation = append(aggregation, fn(selector)) + } + switch n := len(*oshs.selector.flds); { + case n == 0 && len(aggregation) > 0: + selector.Select(aggregation...) + case n != 0 && len(aggregation) > 0: + selector.AppendSelect(aggregation...) + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := oshs.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +// Modify adds a query modifier for attaching custom logic to queries. +func (oshs *OrgSubscriptionHistorySelect) Modify(modifiers ...func(s *sql.Selector)) *OrgSubscriptionHistorySelect { + oshs.modifiers = append(oshs.modifiers, modifiers...) + return oshs +} diff --git a/internal/ent/generated/orgsubscriptionhistory_update.go b/internal/ent/generated/orgsubscriptionhistory_update.go new file mode 100644 index 00000000..f333d98a --- /dev/null +++ b/internal/ent/generated/orgsubscriptionhistory_update.go @@ -0,0 +1,941 @@ +// Code generated by ent, DO NOT EDIT. + +package generated + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/dialect/sql/sqljson" + "entgo.io/ent/schema/field" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" + "github.com/theopenlane/core/internal/ent/generated/predicate" + + "github.com/theopenlane/core/internal/ent/generated/internal" +) + +// OrgSubscriptionHistoryUpdate is the builder for updating OrgSubscriptionHistory entities. +type OrgSubscriptionHistoryUpdate struct { + config + hooks []Hook + mutation *OrgSubscriptionHistoryMutation + modifiers []func(*sql.UpdateBuilder) +} + +// Where appends a list predicates to the OrgSubscriptionHistoryUpdate builder. +func (oshu *OrgSubscriptionHistoryUpdate) Where(ps ...predicate.OrgSubscriptionHistory) *OrgSubscriptionHistoryUpdate { + oshu.mutation.Where(ps...) + return oshu +} + +// SetUpdatedAt sets the "updated_at" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetUpdatedAt(t time.Time) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetUpdatedAt(t) + return oshu +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearUpdatedAt() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearUpdatedAt() + return oshu +} + +// SetUpdatedBy sets the "updated_by" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetUpdatedBy(s string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetUpdatedBy(s) + return oshu +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableUpdatedBy(s *string) *OrgSubscriptionHistoryUpdate { + if s != nil { + oshu.SetUpdatedBy(*s) + } + return oshu +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearUpdatedBy() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearUpdatedBy() + return oshu +} + +// SetTags sets the "tags" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetTags(s []string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetTags(s) + return oshu +} + +// AppendTags appends s to the "tags" field. +func (oshu *OrgSubscriptionHistoryUpdate) AppendTags(s []string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.AppendTags(s) + return oshu +} + +// ClearTags clears the value of the "tags" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearTags() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearTags() + return oshu +} + +// SetDeletedAt sets the "deleted_at" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetDeletedAt(t time.Time) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetDeletedAt(t) + return oshu +} + +// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableDeletedAt(t *time.Time) *OrgSubscriptionHistoryUpdate { + if t != nil { + oshu.SetDeletedAt(*t) + } + return oshu +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearDeletedAt() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearDeletedAt() + return oshu +} + +// SetDeletedBy sets the "deleted_by" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetDeletedBy(s string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetDeletedBy(s) + return oshu +} + +// SetNillableDeletedBy sets the "deleted_by" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableDeletedBy(s *string) *OrgSubscriptionHistoryUpdate { + if s != nil { + oshu.SetDeletedBy(*s) + } + return oshu +} + +// ClearDeletedBy clears the value of the "deleted_by" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearDeletedBy() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearDeletedBy() + return oshu +} + +// SetOwnerID sets the "owner_id" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetOwnerID(s string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetOwnerID(s) + return oshu +} + +// SetNillableOwnerID sets the "owner_id" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableOwnerID(s *string) *OrgSubscriptionHistoryUpdate { + if s != nil { + oshu.SetOwnerID(*s) + } + return oshu +} + +// ClearOwnerID clears the value of the "owner_id" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearOwnerID() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearOwnerID() + return oshu +} + +// SetStripeSubscriptionID sets the "stripe_subscription_id" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetStripeSubscriptionID(s string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetStripeSubscriptionID(s) + return oshu +} + +// SetNillableStripeSubscriptionID sets the "stripe_subscription_id" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableStripeSubscriptionID(s *string) *OrgSubscriptionHistoryUpdate { + if s != nil { + oshu.SetStripeSubscriptionID(*s) + } + return oshu +} + +// ClearStripeSubscriptionID clears the value of the "stripe_subscription_id" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearStripeSubscriptionID() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearStripeSubscriptionID() + return oshu +} + +// SetProductTier sets the "product_tier" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetProductTier(s string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetProductTier(s) + return oshu +} + +// SetNillableProductTier sets the "product_tier" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableProductTier(s *string) *OrgSubscriptionHistoryUpdate { + if s != nil { + oshu.SetProductTier(*s) + } + return oshu +} + +// ClearProductTier clears the value of the "product_tier" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearProductTier() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearProductTier() + return oshu +} + +// SetStripeProductTierID sets the "stripe_product_tier_id" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetStripeProductTierID(s string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetStripeProductTierID(s) + return oshu +} + +// SetNillableStripeProductTierID sets the "stripe_product_tier_id" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableStripeProductTierID(s *string) *OrgSubscriptionHistoryUpdate { + if s != nil { + oshu.SetStripeProductTierID(*s) + } + return oshu +} + +// ClearStripeProductTierID clears the value of the "stripe_product_tier_id" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearStripeProductTierID() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearStripeProductTierID() + return oshu +} + +// SetStripeSubscriptionStatus sets the "stripe_subscription_status" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetStripeSubscriptionStatus(s string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetStripeSubscriptionStatus(s) + return oshu +} + +// SetNillableStripeSubscriptionStatus sets the "stripe_subscription_status" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableStripeSubscriptionStatus(s *string) *OrgSubscriptionHistoryUpdate { + if s != nil { + oshu.SetStripeSubscriptionStatus(*s) + } + return oshu +} + +// ClearStripeSubscriptionStatus clears the value of the "stripe_subscription_status" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearStripeSubscriptionStatus() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearStripeSubscriptionStatus() + return oshu +} + +// SetActive sets the "active" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetActive(b bool) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetActive(b) + return oshu +} + +// SetNillableActive sets the "active" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableActive(b *bool) *OrgSubscriptionHistoryUpdate { + if b != nil { + oshu.SetActive(*b) + } + return oshu +} + +// SetStripeCustomerID sets the "stripe_customer_id" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetStripeCustomerID(s string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetStripeCustomerID(s) + return oshu +} + +// SetNillableStripeCustomerID sets the "stripe_customer_id" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableStripeCustomerID(s *string) *OrgSubscriptionHistoryUpdate { + if s != nil { + oshu.SetStripeCustomerID(*s) + } + return oshu +} + +// ClearStripeCustomerID clears the value of the "stripe_customer_id" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearStripeCustomerID() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearStripeCustomerID() + return oshu +} + +// SetExpiresAt sets the "expires_at" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetExpiresAt(t time.Time) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetExpiresAt(t) + return oshu +} + +// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil. +func (oshu *OrgSubscriptionHistoryUpdate) SetNillableExpiresAt(t *time.Time) *OrgSubscriptionHistoryUpdate { + if t != nil { + oshu.SetExpiresAt(*t) + } + return oshu +} + +// ClearExpiresAt clears the value of the "expires_at" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearExpiresAt() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearExpiresAt() + return oshu +} + +// SetFeatures sets the "features" field. +func (oshu *OrgSubscriptionHistoryUpdate) SetFeatures(s []string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.SetFeatures(s) + return oshu +} + +// AppendFeatures appends s to the "features" field. +func (oshu *OrgSubscriptionHistoryUpdate) AppendFeatures(s []string) *OrgSubscriptionHistoryUpdate { + oshu.mutation.AppendFeatures(s) + return oshu +} + +// ClearFeatures clears the value of the "features" field. +func (oshu *OrgSubscriptionHistoryUpdate) ClearFeatures() *OrgSubscriptionHistoryUpdate { + oshu.mutation.ClearFeatures() + return oshu +} + +// Mutation returns the OrgSubscriptionHistoryMutation object of the builder. +func (oshu *OrgSubscriptionHistoryUpdate) Mutation() *OrgSubscriptionHistoryMutation { + return oshu.mutation +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (oshu *OrgSubscriptionHistoryUpdate) Save(ctx context.Context) (int, error) { + oshu.defaults() + return withHooks(ctx, oshu.sqlSave, oshu.mutation, oshu.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (oshu *OrgSubscriptionHistoryUpdate) SaveX(ctx context.Context) int { + affected, err := oshu.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (oshu *OrgSubscriptionHistoryUpdate) Exec(ctx context.Context) error { + _, err := oshu.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (oshu *OrgSubscriptionHistoryUpdate) ExecX(ctx context.Context) { + if err := oshu.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (oshu *OrgSubscriptionHistoryUpdate) defaults() { + if _, ok := oshu.mutation.UpdatedAt(); !ok && !oshu.mutation.UpdatedAtCleared() { + v := orgsubscriptionhistory.UpdateDefaultUpdatedAt() + oshu.mutation.SetUpdatedAt(v) + } +} + +// Modify adds a statement modifier for attaching custom logic to the UPDATE statement. +func (oshu *OrgSubscriptionHistoryUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *OrgSubscriptionHistoryUpdate { + oshu.modifiers = append(oshu.modifiers, modifiers...) + return oshu +} + +func (oshu *OrgSubscriptionHistoryUpdate) sqlSave(ctx context.Context) (n int, err error) { + _spec := sqlgraph.NewUpdateSpec(orgsubscriptionhistory.Table, orgsubscriptionhistory.Columns, sqlgraph.NewFieldSpec(orgsubscriptionhistory.FieldID, field.TypeString)) + if ps := oshu.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if oshu.mutation.RefCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldRef, field.TypeString) + } + if oshu.mutation.CreatedAtCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldCreatedAt, field.TypeTime) + } + if value, ok := oshu.mutation.UpdatedAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldUpdatedAt, field.TypeTime, value) + } + if oshu.mutation.UpdatedAtCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldUpdatedAt, field.TypeTime) + } + if oshu.mutation.CreatedByCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldCreatedBy, field.TypeString) + } + if value, ok := oshu.mutation.UpdatedBy(); ok { + _spec.SetField(orgsubscriptionhistory.FieldUpdatedBy, field.TypeString, value) + } + if oshu.mutation.UpdatedByCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldUpdatedBy, field.TypeString) + } + if value, ok := oshu.mutation.Tags(); ok { + _spec.SetField(orgsubscriptionhistory.FieldTags, field.TypeJSON, value) + } + if value, ok := oshu.mutation.AppendedTags(); ok { + _spec.AddModifier(func(u *sql.UpdateBuilder) { + sqljson.Append(u, orgsubscriptionhistory.FieldTags, value) + }) + } + if oshu.mutation.TagsCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldTags, field.TypeJSON) + } + if value, ok := oshu.mutation.DeletedAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldDeletedAt, field.TypeTime, value) + } + if oshu.mutation.DeletedAtCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldDeletedAt, field.TypeTime) + } + if value, ok := oshu.mutation.DeletedBy(); ok { + _spec.SetField(orgsubscriptionhistory.FieldDeletedBy, field.TypeString, value) + } + if oshu.mutation.DeletedByCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldDeletedBy, field.TypeString) + } + if value, ok := oshu.mutation.OwnerID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldOwnerID, field.TypeString, value) + } + if oshu.mutation.OwnerIDCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldOwnerID, field.TypeString) + } + if value, ok := oshu.mutation.StripeSubscriptionID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeSubscriptionID, field.TypeString, value) + } + if oshu.mutation.StripeSubscriptionIDCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldStripeSubscriptionID, field.TypeString) + } + if value, ok := oshu.mutation.ProductTier(); ok { + _spec.SetField(orgsubscriptionhistory.FieldProductTier, field.TypeString, value) + } + if oshu.mutation.ProductTierCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldProductTier, field.TypeString) + } + if value, ok := oshu.mutation.StripeProductTierID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeProductTierID, field.TypeString, value) + } + if oshu.mutation.StripeProductTierIDCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldStripeProductTierID, field.TypeString) + } + if value, ok := oshu.mutation.StripeSubscriptionStatus(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeSubscriptionStatus, field.TypeString, value) + } + if oshu.mutation.StripeSubscriptionStatusCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldStripeSubscriptionStatus, field.TypeString) + } + if value, ok := oshu.mutation.Active(); ok { + _spec.SetField(orgsubscriptionhistory.FieldActive, field.TypeBool, value) + } + if value, ok := oshu.mutation.StripeCustomerID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeCustomerID, field.TypeString, value) + } + if oshu.mutation.StripeCustomerIDCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldStripeCustomerID, field.TypeString) + } + if value, ok := oshu.mutation.ExpiresAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldExpiresAt, field.TypeTime, value) + } + if oshu.mutation.ExpiresAtCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldExpiresAt, field.TypeTime) + } + if value, ok := oshu.mutation.Features(); ok { + _spec.SetField(orgsubscriptionhistory.FieldFeatures, field.TypeJSON, value) + } + if value, ok := oshu.mutation.AppendedFeatures(); ok { + _spec.AddModifier(func(u *sql.UpdateBuilder) { + sqljson.Append(u, orgsubscriptionhistory.FieldFeatures, value) + }) + } + if oshu.mutation.FeaturesCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldFeatures, field.TypeJSON) + } + _spec.Node.Schema = oshu.schemaConfig.OrgSubscriptionHistory + ctx = internal.NewSchemaConfigContext(ctx, oshu.schemaConfig) + _spec.AddModifiers(oshu.modifiers...) + if n, err = sqlgraph.UpdateNodes(ctx, oshu.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{orgsubscriptionhistory.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + oshu.mutation.done = true + return n, nil +} + +// OrgSubscriptionHistoryUpdateOne is the builder for updating a single OrgSubscriptionHistory entity. +type OrgSubscriptionHistoryUpdateOne struct { + config + fields []string + hooks []Hook + mutation *OrgSubscriptionHistoryMutation + modifiers []func(*sql.UpdateBuilder) +} + +// SetUpdatedAt sets the "updated_at" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetUpdatedAt(t time.Time) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetUpdatedAt(t) + return oshuo +} + +// ClearUpdatedAt clears the value of the "updated_at" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearUpdatedAt() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearUpdatedAt() + return oshuo +} + +// SetUpdatedBy sets the "updated_by" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetUpdatedBy(s string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetUpdatedBy(s) + return oshuo +} + +// SetNillableUpdatedBy sets the "updated_by" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableUpdatedBy(s *string) *OrgSubscriptionHistoryUpdateOne { + if s != nil { + oshuo.SetUpdatedBy(*s) + } + return oshuo +} + +// ClearUpdatedBy clears the value of the "updated_by" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearUpdatedBy() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearUpdatedBy() + return oshuo +} + +// SetTags sets the "tags" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetTags(s []string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetTags(s) + return oshuo +} + +// AppendTags appends s to the "tags" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) AppendTags(s []string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.AppendTags(s) + return oshuo +} + +// ClearTags clears the value of the "tags" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearTags() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearTags() + return oshuo +} + +// SetDeletedAt sets the "deleted_at" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetDeletedAt(t time.Time) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetDeletedAt(t) + return oshuo +} + +// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableDeletedAt(t *time.Time) *OrgSubscriptionHistoryUpdateOne { + if t != nil { + oshuo.SetDeletedAt(*t) + } + return oshuo +} + +// ClearDeletedAt clears the value of the "deleted_at" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearDeletedAt() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearDeletedAt() + return oshuo +} + +// SetDeletedBy sets the "deleted_by" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetDeletedBy(s string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetDeletedBy(s) + return oshuo +} + +// SetNillableDeletedBy sets the "deleted_by" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableDeletedBy(s *string) *OrgSubscriptionHistoryUpdateOne { + if s != nil { + oshuo.SetDeletedBy(*s) + } + return oshuo +} + +// ClearDeletedBy clears the value of the "deleted_by" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearDeletedBy() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearDeletedBy() + return oshuo +} + +// SetOwnerID sets the "owner_id" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetOwnerID(s string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetOwnerID(s) + return oshuo +} + +// SetNillableOwnerID sets the "owner_id" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableOwnerID(s *string) *OrgSubscriptionHistoryUpdateOne { + if s != nil { + oshuo.SetOwnerID(*s) + } + return oshuo +} + +// ClearOwnerID clears the value of the "owner_id" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearOwnerID() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearOwnerID() + return oshuo +} + +// SetStripeSubscriptionID sets the "stripe_subscription_id" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetStripeSubscriptionID(s string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetStripeSubscriptionID(s) + return oshuo +} + +// SetNillableStripeSubscriptionID sets the "stripe_subscription_id" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableStripeSubscriptionID(s *string) *OrgSubscriptionHistoryUpdateOne { + if s != nil { + oshuo.SetStripeSubscriptionID(*s) + } + return oshuo +} + +// ClearStripeSubscriptionID clears the value of the "stripe_subscription_id" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearStripeSubscriptionID() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearStripeSubscriptionID() + return oshuo +} + +// SetProductTier sets the "product_tier" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetProductTier(s string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetProductTier(s) + return oshuo +} + +// SetNillableProductTier sets the "product_tier" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableProductTier(s *string) *OrgSubscriptionHistoryUpdateOne { + if s != nil { + oshuo.SetProductTier(*s) + } + return oshuo +} + +// ClearProductTier clears the value of the "product_tier" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearProductTier() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearProductTier() + return oshuo +} + +// SetStripeProductTierID sets the "stripe_product_tier_id" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetStripeProductTierID(s string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetStripeProductTierID(s) + return oshuo +} + +// SetNillableStripeProductTierID sets the "stripe_product_tier_id" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableStripeProductTierID(s *string) *OrgSubscriptionHistoryUpdateOne { + if s != nil { + oshuo.SetStripeProductTierID(*s) + } + return oshuo +} + +// ClearStripeProductTierID clears the value of the "stripe_product_tier_id" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearStripeProductTierID() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearStripeProductTierID() + return oshuo +} + +// SetStripeSubscriptionStatus sets the "stripe_subscription_status" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetStripeSubscriptionStatus(s string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetStripeSubscriptionStatus(s) + return oshuo +} + +// SetNillableStripeSubscriptionStatus sets the "stripe_subscription_status" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableStripeSubscriptionStatus(s *string) *OrgSubscriptionHistoryUpdateOne { + if s != nil { + oshuo.SetStripeSubscriptionStatus(*s) + } + return oshuo +} + +// ClearStripeSubscriptionStatus clears the value of the "stripe_subscription_status" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearStripeSubscriptionStatus() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearStripeSubscriptionStatus() + return oshuo +} + +// SetActive sets the "active" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetActive(b bool) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetActive(b) + return oshuo +} + +// SetNillableActive sets the "active" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableActive(b *bool) *OrgSubscriptionHistoryUpdateOne { + if b != nil { + oshuo.SetActive(*b) + } + return oshuo +} + +// SetStripeCustomerID sets the "stripe_customer_id" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetStripeCustomerID(s string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetStripeCustomerID(s) + return oshuo +} + +// SetNillableStripeCustomerID sets the "stripe_customer_id" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableStripeCustomerID(s *string) *OrgSubscriptionHistoryUpdateOne { + if s != nil { + oshuo.SetStripeCustomerID(*s) + } + return oshuo +} + +// ClearStripeCustomerID clears the value of the "stripe_customer_id" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearStripeCustomerID() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearStripeCustomerID() + return oshuo +} + +// SetExpiresAt sets the "expires_at" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetExpiresAt(t time.Time) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetExpiresAt(t) + return oshuo +} + +// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetNillableExpiresAt(t *time.Time) *OrgSubscriptionHistoryUpdateOne { + if t != nil { + oshuo.SetExpiresAt(*t) + } + return oshuo +} + +// ClearExpiresAt clears the value of the "expires_at" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearExpiresAt() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearExpiresAt() + return oshuo +} + +// SetFeatures sets the "features" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SetFeatures(s []string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.SetFeatures(s) + return oshuo +} + +// AppendFeatures appends s to the "features" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) AppendFeatures(s []string) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.AppendFeatures(s) + return oshuo +} + +// ClearFeatures clears the value of the "features" field. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ClearFeatures() *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.ClearFeatures() + return oshuo +} + +// Mutation returns the OrgSubscriptionHistoryMutation object of the builder. +func (oshuo *OrgSubscriptionHistoryUpdateOne) Mutation() *OrgSubscriptionHistoryMutation { + return oshuo.mutation +} + +// Where appends a list predicates to the OrgSubscriptionHistoryUpdate builder. +func (oshuo *OrgSubscriptionHistoryUpdateOne) Where(ps ...predicate.OrgSubscriptionHistory) *OrgSubscriptionHistoryUpdateOne { + oshuo.mutation.Where(ps...) + return oshuo +} + +// Select allows selecting one or more fields (columns) of the returned entity. +// The default is selecting all fields defined in the entity schema. +func (oshuo *OrgSubscriptionHistoryUpdateOne) Select(field string, fields ...string) *OrgSubscriptionHistoryUpdateOne { + oshuo.fields = append([]string{field}, fields...) + return oshuo +} + +// Save executes the query and returns the updated OrgSubscriptionHistory entity. +func (oshuo *OrgSubscriptionHistoryUpdateOne) Save(ctx context.Context) (*OrgSubscriptionHistory, error) { + oshuo.defaults() + return withHooks(ctx, oshuo.sqlSave, oshuo.mutation, oshuo.hooks) +} + +// SaveX is like Save, but panics if an error occurs. +func (oshuo *OrgSubscriptionHistoryUpdateOne) SaveX(ctx context.Context) *OrgSubscriptionHistory { + node, err := oshuo.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (oshuo *OrgSubscriptionHistoryUpdateOne) Exec(ctx context.Context) error { + _, err := oshuo.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (oshuo *OrgSubscriptionHistoryUpdateOne) ExecX(ctx context.Context) { + if err := oshuo.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (oshuo *OrgSubscriptionHistoryUpdateOne) defaults() { + if _, ok := oshuo.mutation.UpdatedAt(); !ok && !oshuo.mutation.UpdatedAtCleared() { + v := orgsubscriptionhistory.UpdateDefaultUpdatedAt() + oshuo.mutation.SetUpdatedAt(v) + } +} + +// Modify adds a statement modifier for attaching custom logic to the UPDATE statement. +func (oshuo *OrgSubscriptionHistoryUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *OrgSubscriptionHistoryUpdateOne { + oshuo.modifiers = append(oshuo.modifiers, modifiers...) + return oshuo +} + +func (oshuo *OrgSubscriptionHistoryUpdateOne) sqlSave(ctx context.Context) (_node *OrgSubscriptionHistory, err error) { + _spec := sqlgraph.NewUpdateSpec(orgsubscriptionhistory.Table, orgsubscriptionhistory.Columns, sqlgraph.NewFieldSpec(orgsubscriptionhistory.FieldID, field.TypeString)) + id, ok := oshuo.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`generated: missing "OrgSubscriptionHistory.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := oshuo.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, orgsubscriptionhistory.FieldID) + for _, f := range fields { + if !orgsubscriptionhistory.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("generated: invalid field %q for query", f)} + } + if f != orgsubscriptionhistory.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := oshuo.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if oshuo.mutation.RefCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldRef, field.TypeString) + } + if oshuo.mutation.CreatedAtCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldCreatedAt, field.TypeTime) + } + if value, ok := oshuo.mutation.UpdatedAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldUpdatedAt, field.TypeTime, value) + } + if oshuo.mutation.UpdatedAtCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldUpdatedAt, field.TypeTime) + } + if oshuo.mutation.CreatedByCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldCreatedBy, field.TypeString) + } + if value, ok := oshuo.mutation.UpdatedBy(); ok { + _spec.SetField(orgsubscriptionhistory.FieldUpdatedBy, field.TypeString, value) + } + if oshuo.mutation.UpdatedByCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldUpdatedBy, field.TypeString) + } + if value, ok := oshuo.mutation.Tags(); ok { + _spec.SetField(orgsubscriptionhistory.FieldTags, field.TypeJSON, value) + } + if value, ok := oshuo.mutation.AppendedTags(); ok { + _spec.AddModifier(func(u *sql.UpdateBuilder) { + sqljson.Append(u, orgsubscriptionhistory.FieldTags, value) + }) + } + if oshuo.mutation.TagsCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldTags, field.TypeJSON) + } + if value, ok := oshuo.mutation.DeletedAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldDeletedAt, field.TypeTime, value) + } + if oshuo.mutation.DeletedAtCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldDeletedAt, field.TypeTime) + } + if value, ok := oshuo.mutation.DeletedBy(); ok { + _spec.SetField(orgsubscriptionhistory.FieldDeletedBy, field.TypeString, value) + } + if oshuo.mutation.DeletedByCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldDeletedBy, field.TypeString) + } + if value, ok := oshuo.mutation.OwnerID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldOwnerID, field.TypeString, value) + } + if oshuo.mutation.OwnerIDCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldOwnerID, field.TypeString) + } + if value, ok := oshuo.mutation.StripeSubscriptionID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeSubscriptionID, field.TypeString, value) + } + if oshuo.mutation.StripeSubscriptionIDCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldStripeSubscriptionID, field.TypeString) + } + if value, ok := oshuo.mutation.ProductTier(); ok { + _spec.SetField(orgsubscriptionhistory.FieldProductTier, field.TypeString, value) + } + if oshuo.mutation.ProductTierCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldProductTier, field.TypeString) + } + if value, ok := oshuo.mutation.StripeProductTierID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeProductTierID, field.TypeString, value) + } + if oshuo.mutation.StripeProductTierIDCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldStripeProductTierID, field.TypeString) + } + if value, ok := oshuo.mutation.StripeSubscriptionStatus(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeSubscriptionStatus, field.TypeString, value) + } + if oshuo.mutation.StripeSubscriptionStatusCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldStripeSubscriptionStatus, field.TypeString) + } + if value, ok := oshuo.mutation.Active(); ok { + _spec.SetField(orgsubscriptionhistory.FieldActive, field.TypeBool, value) + } + if value, ok := oshuo.mutation.StripeCustomerID(); ok { + _spec.SetField(orgsubscriptionhistory.FieldStripeCustomerID, field.TypeString, value) + } + if oshuo.mutation.StripeCustomerIDCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldStripeCustomerID, field.TypeString) + } + if value, ok := oshuo.mutation.ExpiresAt(); ok { + _spec.SetField(orgsubscriptionhistory.FieldExpiresAt, field.TypeTime, value) + } + if oshuo.mutation.ExpiresAtCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldExpiresAt, field.TypeTime) + } + if value, ok := oshuo.mutation.Features(); ok { + _spec.SetField(orgsubscriptionhistory.FieldFeatures, field.TypeJSON, value) + } + if value, ok := oshuo.mutation.AppendedFeatures(); ok { + _spec.AddModifier(func(u *sql.UpdateBuilder) { + sqljson.Append(u, orgsubscriptionhistory.FieldFeatures, value) + }) + } + if oshuo.mutation.FeaturesCleared() { + _spec.ClearField(orgsubscriptionhistory.FieldFeatures, field.TypeJSON) + } + _spec.Node.Schema = oshuo.schemaConfig.OrgSubscriptionHistory + ctx = internal.NewSchemaConfigContext(ctx, oshuo.schemaConfig) + _spec.AddModifiers(oshuo.modifiers...) + _node = &OrgSubscriptionHistory{config: oshuo.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, oshuo.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{orgsubscriptionhistory.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + oshuo.mutation.done = true + return _node, nil +} diff --git a/internal/ent/generated/predicate/predicate.go b/internal/ent/generated/predicate/predicate.go index 17242065..260a3a47 100644 --- a/internal/ent/generated/predicate/predicate.go +++ b/internal/ent/generated/predicate/predicate.go @@ -156,6 +156,12 @@ type OrgMembership func(*sql.Selector) // OrgMembershipHistory is the predicate function for orgmembershiphistory builders. type OrgMembershipHistory func(*sql.Selector) +// OrgSubscription is the predicate function for orgsubscription builders. +type OrgSubscription func(*sql.Selector) + +// OrgSubscriptionHistory is the predicate function for orgsubscriptionhistory builders. +type OrgSubscriptionHistory func(*sql.Selector) + // Organization is the predicate function for organization builders. type Organization func(*sql.Selector) diff --git a/internal/ent/generated/privacy/privacy.go b/internal/ent/generated/privacy/privacy.go index 036b63a8..ced49a08 100644 --- a/internal/ent/generated/privacy/privacy.go +++ b/internal/ent/generated/privacy/privacy.go @@ -1311,6 +1311,54 @@ func (f OrgMembershipHistoryMutationRuleFunc) EvalMutation(ctx context.Context, return Denyf("generated/privacy: unexpected mutation type %T, expect *generated.OrgMembershipHistoryMutation", m) } +// The OrgSubscriptionQueryRuleFunc type is an adapter to allow the use of ordinary +// functions as a query rule. +type OrgSubscriptionQueryRuleFunc func(context.Context, *generated.OrgSubscriptionQuery) error + +// EvalQuery return f(ctx, q). +func (f OrgSubscriptionQueryRuleFunc) EvalQuery(ctx context.Context, q generated.Query) error { + if q, ok := q.(*generated.OrgSubscriptionQuery); ok { + return f(ctx, q) + } + return Denyf("generated/privacy: unexpected query type %T, expect *generated.OrgSubscriptionQuery", q) +} + +// The OrgSubscriptionMutationRuleFunc type is an adapter to allow the use of ordinary +// functions as a mutation rule. +type OrgSubscriptionMutationRuleFunc func(context.Context, *generated.OrgSubscriptionMutation) error + +// EvalMutation calls f(ctx, m). +func (f OrgSubscriptionMutationRuleFunc) EvalMutation(ctx context.Context, m generated.Mutation) error { + if m, ok := m.(*generated.OrgSubscriptionMutation); ok { + return f(ctx, m) + } + return Denyf("generated/privacy: unexpected mutation type %T, expect *generated.OrgSubscriptionMutation", m) +} + +// The OrgSubscriptionHistoryQueryRuleFunc type is an adapter to allow the use of ordinary +// functions as a query rule. +type OrgSubscriptionHistoryQueryRuleFunc func(context.Context, *generated.OrgSubscriptionHistoryQuery) error + +// EvalQuery return f(ctx, q). +func (f OrgSubscriptionHistoryQueryRuleFunc) EvalQuery(ctx context.Context, q generated.Query) error { + if q, ok := q.(*generated.OrgSubscriptionHistoryQuery); ok { + return f(ctx, q) + } + return Denyf("generated/privacy: unexpected query type %T, expect *generated.OrgSubscriptionHistoryQuery", q) +} + +// The OrgSubscriptionHistoryMutationRuleFunc type is an adapter to allow the use of ordinary +// functions as a mutation rule. +type OrgSubscriptionHistoryMutationRuleFunc func(context.Context, *generated.OrgSubscriptionHistoryMutation) error + +// EvalMutation calls f(ctx, m). +func (f OrgSubscriptionHistoryMutationRuleFunc) EvalMutation(ctx context.Context, m generated.Mutation) error { + if m, ok := m.(*generated.OrgSubscriptionHistoryMutation); ok { + return f(ctx, m) + } + return Denyf("generated/privacy: unexpected mutation type %T, expect *generated.OrgSubscriptionHistoryMutation", m) +} + // The OrganizationQueryRuleFunc type is an adapter to allow the use of ordinary // functions as a query rule. type OrganizationQueryRuleFunc func(context.Context, *generated.OrganizationQuery) error @@ -2190,6 +2238,10 @@ func queryFilter(q generated.Query) (Filter, error) { return q.Filter(), nil case *generated.OrgMembershipHistoryQuery: return q.Filter(), nil + case *generated.OrgSubscriptionQuery: + return q.Filter(), nil + case *generated.OrgSubscriptionHistoryQuery: + return q.Filter(), nil case *generated.OrganizationQuery: return q.Filter(), nil case *generated.OrganizationHistoryQuery: @@ -2359,6 +2411,10 @@ func mutationFilter(m generated.Mutation) (Filter, error) { return m.Filter(), nil case *generated.OrgMembershipHistoryMutation: return m.Filter(), nil + case *generated.OrgSubscriptionMutation: + return m.Filter(), nil + case *generated.OrgSubscriptionHistoryMutation: + return m.Filter(), nil case *generated.OrganizationMutation: return m.Filter(), nil case *generated.OrganizationHistoryMutation: diff --git a/internal/ent/generated/runtime/runtime.go b/internal/ent/generated/runtime/runtime.go index ec3bbe3b..7a119e9f 100644 --- a/internal/ent/generated/runtime/runtime.go +++ b/internal/ent/generated/runtime/runtime.go @@ -60,6 +60,8 @@ import ( "github.com/theopenlane/core/internal/ent/generated/organizationsettinghistory" "github.com/theopenlane/core/internal/ent/generated/orgmembership" "github.com/theopenlane/core/internal/ent/generated/orgmembershiphistory" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" + "github.com/theopenlane/core/internal/ent/generated/orgsubscriptionhistory" "github.com/theopenlane/core/internal/ent/generated/passwordresettoken" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/procedure" @@ -2770,6 +2772,89 @@ func init() { orgmembershiphistoryDescID := orgmembershiphistoryFields[7].Descriptor() // orgmembershiphistory.DefaultID holds the default value on creation for the id field. orgmembershiphistory.DefaultID = orgmembershiphistoryDescID.Default.(func() string) + orgsubscriptionMixin := schema.OrgSubscription{}.Mixin() + orgsubscriptionMixinHooks0 := orgsubscriptionMixin[0].Hooks() + orgsubscriptionMixinHooks3 := orgsubscriptionMixin[3].Hooks() + orgsubscriptionMixinHooks4 := orgsubscriptionMixin[4].Hooks() + orgsubscription.Hooks[0] = orgsubscriptionMixinHooks0[0] + orgsubscription.Hooks[1] = orgsubscriptionMixinHooks3[0] + orgsubscription.Hooks[2] = orgsubscriptionMixinHooks4[0] + orgsubscriptionMixinInters3 := orgsubscriptionMixin[3].Interceptors() + orgsubscriptionMixinInters4 := orgsubscriptionMixin[4].Interceptors() + orgsubscription.Interceptors[0] = orgsubscriptionMixinInters3[0] + orgsubscription.Interceptors[1] = orgsubscriptionMixinInters4[0] + orgsubscriptionMixinFields0 := orgsubscriptionMixin[0].Fields() + _ = orgsubscriptionMixinFields0 + orgsubscriptionMixinFields1 := orgsubscriptionMixin[1].Fields() + _ = orgsubscriptionMixinFields1 + orgsubscriptionMixinFields2 := orgsubscriptionMixin[2].Fields() + _ = orgsubscriptionMixinFields2 + orgsubscriptionMixinFields4 := orgsubscriptionMixin[4].Fields() + _ = orgsubscriptionMixinFields4 + orgsubscriptionFields := schema.OrgSubscription{}.Fields() + _ = orgsubscriptionFields + // orgsubscriptionDescCreatedAt is the schema descriptor for created_at field. + orgsubscriptionDescCreatedAt := orgsubscriptionMixinFields0[0].Descriptor() + // orgsubscription.DefaultCreatedAt holds the default value on creation for the created_at field. + orgsubscription.DefaultCreatedAt = orgsubscriptionDescCreatedAt.Default.(func() time.Time) + // orgsubscriptionDescUpdatedAt is the schema descriptor for updated_at field. + orgsubscriptionDescUpdatedAt := orgsubscriptionMixinFields0[1].Descriptor() + // orgsubscription.DefaultUpdatedAt holds the default value on creation for the updated_at field. + orgsubscription.DefaultUpdatedAt = orgsubscriptionDescUpdatedAt.Default.(func() time.Time) + // orgsubscription.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field. + orgsubscription.UpdateDefaultUpdatedAt = orgsubscriptionDescUpdatedAt.UpdateDefault.(func() time.Time) + // orgsubscriptionDescMappingID is the schema descriptor for mapping_id field. + orgsubscriptionDescMappingID := orgsubscriptionMixinFields1[1].Descriptor() + // orgsubscription.DefaultMappingID holds the default value on creation for the mapping_id field. + orgsubscription.DefaultMappingID = orgsubscriptionDescMappingID.Default.(func() string) + // orgsubscriptionDescTags is the schema descriptor for tags field. + orgsubscriptionDescTags := orgsubscriptionMixinFields2[0].Descriptor() + // orgsubscription.DefaultTags holds the default value on creation for the tags field. + orgsubscription.DefaultTags = orgsubscriptionDescTags.Default.([]string) + // orgsubscriptionDescOwnerID is the schema descriptor for owner_id field. + orgsubscriptionDescOwnerID := orgsubscriptionMixinFields4[0].Descriptor() + // orgsubscription.OwnerIDValidator is a validator for the "owner_id" field. It is called by the builders before save. + orgsubscription.OwnerIDValidator = orgsubscriptionDescOwnerID.Validators[0].(func(string) error) + // orgsubscriptionDescActive is the schema descriptor for active field. + orgsubscriptionDescActive := orgsubscriptionFields[4].Descriptor() + // orgsubscription.DefaultActive holds the default value on creation for the active field. + orgsubscription.DefaultActive = orgsubscriptionDescActive.Default.(bool) + // orgsubscriptionDescID is the schema descriptor for id field. + orgsubscriptionDescID := orgsubscriptionMixinFields1[0].Descriptor() + // orgsubscription.DefaultID holds the default value on creation for the id field. + orgsubscription.DefaultID = orgsubscriptionDescID.Default.(func() string) + orgsubscriptionhistoryFields := schema.OrgSubscriptionHistory{}.Fields() + _ = orgsubscriptionhistoryFields + // orgsubscriptionhistoryDescHistoryTime is the schema descriptor for history_time field. + orgsubscriptionhistoryDescHistoryTime := orgsubscriptionhistoryFields[0].Descriptor() + // orgsubscriptionhistory.DefaultHistoryTime holds the default value on creation for the history_time field. + orgsubscriptionhistory.DefaultHistoryTime = orgsubscriptionhistoryDescHistoryTime.Default.(func() time.Time) + // orgsubscriptionhistoryDescCreatedAt is the schema descriptor for created_at field. + orgsubscriptionhistoryDescCreatedAt := orgsubscriptionhistoryFields[3].Descriptor() + // orgsubscriptionhistory.DefaultCreatedAt holds the default value on creation for the created_at field. + orgsubscriptionhistory.DefaultCreatedAt = orgsubscriptionhistoryDescCreatedAt.Default.(func() time.Time) + // orgsubscriptionhistoryDescUpdatedAt is the schema descriptor for updated_at field. + orgsubscriptionhistoryDescUpdatedAt := orgsubscriptionhistoryFields[4].Descriptor() + // orgsubscriptionhistory.DefaultUpdatedAt holds the default value on creation for the updated_at field. + orgsubscriptionhistory.DefaultUpdatedAt = orgsubscriptionhistoryDescUpdatedAt.Default.(func() time.Time) + // orgsubscriptionhistory.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field. + orgsubscriptionhistory.UpdateDefaultUpdatedAt = orgsubscriptionhistoryDescUpdatedAt.UpdateDefault.(func() time.Time) + // orgsubscriptionhistoryDescMappingID is the schema descriptor for mapping_id field. + orgsubscriptionhistoryDescMappingID := orgsubscriptionhistoryFields[8].Descriptor() + // orgsubscriptionhistory.DefaultMappingID holds the default value on creation for the mapping_id field. + orgsubscriptionhistory.DefaultMappingID = orgsubscriptionhistoryDescMappingID.Default.(func() string) + // orgsubscriptionhistoryDescTags is the schema descriptor for tags field. + orgsubscriptionhistoryDescTags := orgsubscriptionhistoryFields[9].Descriptor() + // orgsubscriptionhistory.DefaultTags holds the default value on creation for the tags field. + orgsubscriptionhistory.DefaultTags = orgsubscriptionhistoryDescTags.Default.([]string) + // orgsubscriptionhistoryDescActive is the schema descriptor for active field. + orgsubscriptionhistoryDescActive := orgsubscriptionhistoryFields[17].Descriptor() + // orgsubscriptionhistory.DefaultActive holds the default value on creation for the active field. + orgsubscriptionhistory.DefaultActive = orgsubscriptionhistoryDescActive.Default.(bool) + // orgsubscriptionhistoryDescID is the schema descriptor for id field. + orgsubscriptionhistoryDescID := orgsubscriptionhistoryFields[7].Descriptor() + // orgsubscriptionhistory.DefaultID holds the default value on creation for the id field. + orgsubscriptionhistory.DefaultID = orgsubscriptionhistoryDescID.Default.(func() string) organizationMixin := schema.Organization{}.Mixin() organization.Policy = privacy.NewPolicies(schema.Organization{}) organization.Hooks[0] = func(next ent.Mutator) ent.Mutator { diff --git a/internal/ent/generated/tx.go b/internal/ent/generated/tx.go index cd0b2aa5..34a6d41c 100644 --- a/internal/ent/generated/tx.go +++ b/internal/ent/generated/tx.go @@ -112,6 +112,10 @@ type Tx struct { OrgMembership *OrgMembershipClient // OrgMembershipHistory is the client for interacting with the OrgMembershipHistory builders. OrgMembershipHistory *OrgMembershipHistoryClient + // OrgSubscription is the client for interacting with the OrgSubscription builders. + OrgSubscription *OrgSubscriptionClient + // OrgSubscriptionHistory is the client for interacting with the OrgSubscriptionHistory builders. + OrgSubscriptionHistory *OrgSubscriptionHistoryClient // Organization is the client for interacting with the Organization builders. Organization *OrganizationClient // OrganizationHistory is the client for interacting with the OrganizationHistory builders. @@ -355,6 +359,8 @@ func (tx *Tx) init() { tx.OhAuthTooToken = NewOhAuthTooTokenClient(tx.config) tx.OrgMembership = NewOrgMembershipClient(tx.config) tx.OrgMembershipHistory = NewOrgMembershipHistoryClient(tx.config) + tx.OrgSubscription = NewOrgSubscriptionClient(tx.config) + tx.OrgSubscriptionHistory = NewOrgSubscriptionHistoryClient(tx.config) tx.Organization = NewOrganizationClient(tx.config) tx.OrganizationHistory = NewOrganizationHistoryClient(tx.config) tx.OrganizationSetting = NewOrganizationSettingClient(tx.config) diff --git a/internal/ent/hooks/event.go b/internal/ent/hooks/event.go index 0908b3ed..3e176979 100644 --- a/internal/ent/hooks/event.go +++ b/internal/ent/hooks/event.go @@ -169,26 +169,57 @@ func RegisterGlobalHooks(client *entgen.Client, e *Eventer) { // RegisterListeners is currently used to globally register what listeners get applied on the entdb client func RegisterListeners(e *Eventer) error { - for _, event := range []string{OrganizationSettingCreate, OrganizationSettingUpdateOne} { - _, err := e.Emitter.On(event, handleOrganizationSettingEvents) - if err != nil { - log.Error().Err(ErrFailedToRegisterListener) + _, err := e.Emitter.On(OrganizationSettingCreate, handleOrganizationSettingsCreate) + if err != nil { + log.Error().Err(ErrFailedToRegisterListener) + return err + } + + _, err = e.Emitter.On(OrganizationSettingUpdateOne, handleOrganizationSettingsUpdateOne) + if err != nil { + log.Error().Err(ErrFailedToRegisterListener) + return err + } + + return nil +} + +// handleOrganizationSettingsUpdateOne checks for updates to the organization settings and updates the customer in Stripe accordingly +func handleOrganizationSettingsUpdateOne(event soiree.Event) error { + client := event.Client().(*entgen.Client) + entMgr := client.EntitlementManager + + if entMgr == nil { + log.Debug().Msg("EntitlementManager not found on client, skipping customer creation") + + return nil + } + + orgCust, err := fetchOrganizationIDbyOrgSettingID(event.Context(), lo.ValueOr(event.Properties(), "ID", "").(string), client) + if err != nil { + log.Err(err).Msg("Failed to fetch organization ID by organization setting ID") + + return err + } + + if params, hasUpdate := entitlements.CheckForBillingUpdate(event.Properties(), orgCust); hasUpdate { + if _, err := entMgr.UpdateCustomer(orgCust.StripeCustomerID, params); err != nil { + log.Err(err).Msg("Failed to update customer") + return err } - - log.Debug().Msg("Listener registered for " + event) } return nil } -// handleCustomerCreate handles the creation of a customer in Stripe when an OrganizationSetting is created or updated -func handleOrganizationSettingEvents(event soiree.Event) error { +// handleOrganizationSettingsCreate handles the creation of a customer in Stripe when an OrganizationSetting is created or updated +func handleOrganizationSettingsCreate(event soiree.Event) error { client := event.Client().(*entgen.Client) entMgr := client.EntitlementManager if entMgr == nil { - log.Info().Msg("EntitlementManager not found on client, skipping customer creation") + log.Debug().Msg("EntitlementManager not found on client, skipping customer creation") return nil } @@ -200,6 +231,7 @@ func handleOrganizationSettingEvents(event soiree.Event) error { return err } + // our resolvers support creating organizations + settings with attributes in the payload, so in the event this is populated we want to do nothing if orgCust.StripeCustomerID == "" { customer, err := entMgr.FindorCreateCustomer(event.Context(), orgCust) if err != nil { @@ -208,34 +240,33 @@ func handleOrganizationSettingEvents(event soiree.Event) error { return err } - if err := updateOrganizationSettingWithCustomerID(event.Context(), orgCust.OrganizationSettingsID, customer.StripeCustomerID, client); err != nil { - log.Err(err).Msg("Failed to update organization setting with customer ID") + if err := createInternalOrgSubscription(event.Context(), customer, client); err != nil { + log.Err(err).Msg("Failed to create internal org subscription") return err } return nil - } else { - if params, hasUpdate := entitlements.CheckForBillingUpdate(event.Properties(), orgCust); hasUpdate { - if _, err := entMgr.UpdateCustomer(orgCust.StripeCustomerID, params); err != nil { - log.Err(err).Msg("Failed to update customer") - - return err - } - } } return nil } -// updateOrganizationSettingWithCustomerID updates an OrganizationSetting with a Stripe customer ID -func updateOrganizationSettingWithCustomerID(ctx context.Context, orgsettingID, customerID string, client interface{}) error { - if _, err := client.(*entgen.Client).OrganizationSetting.UpdateOneID(orgsettingID).SetStripeID(customerID).Save(ctx); err != nil { - log.Err(err).Msgf("Failed to update OrganizationSetting ID %s with Stripe customer ID %s", orgsettingID, customerID) - +// createInternalOrgSubscription creates an internal org subscription +func createInternalOrgSubscription(ctx context.Context, customer *entitlements.OrganizationCustomer, client interface{}) error { + sub, err := client.(*entgen.Client).OrgSubscription.Create(). + SetStripeSubscriptionID(customer.Subscription.ID). + SetOwnerID(customer.OrganizationID). + SetStripeCustomerID(customer.StripeCustomerID). + SetFeatures(customer.Features). + Save(ctx) + if err != nil { + log.Err(err).Msg("Failed to create internal org subscription") return err } + log.Info().Msgf("Created internal org subscription with ID %s", sub.ID) + return nil } diff --git a/internal/ent/schema/organization.go b/internal/ent/schema/organization.go index 7c425506..14104185 100644 --- a/internal/ent/schema/organization.go +++ b/internal/ent/schema/organization.go @@ -135,7 +135,10 @@ func (Organization) Edges() []ent.Edge { Annotations( entx.CascadeAnnotationField("Owner"), ), - // Organization that is assigned the entitlement + edge.To("orgsubscriptions", OrgSubscription.Type). + Annotations( + entx.CascadeAnnotationField("Owner"), + ), edge.To("organization_entitlement", Entitlement.Type), edge.To("personal_access_tokens", PersonalAccessToken.Type), edge.To("api_tokens", APIToken.Type), diff --git a/internal/ent/schema/orgsubscription.go b/internal/ent/schema/orgsubscription.go new file mode 100644 index 00000000..02a4e8c2 --- /dev/null +++ b/internal/ent/schema/orgsubscription.go @@ -0,0 +1,102 @@ +package schema + +import ( + "entgo.io/contrib/entgql" + "entgo.io/ent" + "entgo.io/ent/schema" + "entgo.io/ent/schema/field" + + emixin "github.com/theopenlane/entx/mixin" + + "github.com/theopenlane/core/internal/ent/mixin" +) + +// OrgSubscription holds the schema definition for the OrgSubscription entity +type OrgSubscription struct { + ent.Schema +} + +// Fields of the OrgSubscription +func (OrgSubscription) Fields() []ent.Field { + return []ent.Field{ + field.String("stripe_subscription_id"). + Comment("the stripe subscription id"). + Optional(), + field.String("product_tier"). + Comment("the common name of the product tier the subscription is associated with, e.g. starter tier"). + Optional(), + field.String("stripe_product_tier_id"). + Comment("the product id that represents the tier in stripe"). + Optional(), + field.String("stripe_subscription_status"). + Comment("the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status"). + Optional(), + field.Bool("active"). + Comment("indicates if the subscription is active"). + Default(true), + field.String("stripe_customer_id"). + Comment("the customer ID the subscription is associated to"). + Unique(). + Optional(), + field.Time("expires_at"). + Comment("the time the subscription is set to expire; only populated if subscription is cancelled"). + Nillable(). + Optional(), + field.JSON("features", []string{}). + Comment("the features associated with the subscription"). + Optional(), + } +} + +// Mixin of the OrgSubscription +func (OrgSubscription) Mixin() []ent.Mixin { + return []ent.Mixin{ + emixin.AuditMixin{}, + emixin.IDMixin{}, + emixin.TagMixin{}, + mixin.SoftDeleteMixin{}, + NewOrgOwnMixinWithRef("orgsubscriptions"), + } +} + +// Edges of the OrgSubscription +func (OrgSubscription) Edges() []ent.Edge { + return []ent.Edge{} +} + +// Indexes of the OrgSubscription +func (OrgSubscription) Indexes() []ent.Index { + return []ent.Index{} +} + +// Annotations of the OrgSubscription +func (OrgSubscription) Annotations() []schema.Annotation { + return []schema.Annotation{ + entgql.QueryField(), + entgql.RelayConnection(), + entgql.Mutations(entgql.MutationCreate(), (entgql.MutationUpdate())), + } +} + +// Hooks of the OrgSubscription +func (OrgSubscription) Hooks() []ent.Hook { + return []ent.Hook{} +} + +// Interceptors of the OrgSubscription +func (OrgSubscription) Interceptors() []ent.Interceptor { + return []ent.Interceptor{} +} + +// Policy of the OrgSubscription +//func (OrgSubscription) Policy() ent.Policy { +// return policy.NewPolicy( +// policy.WithQueryRules( +// entfga.CheckReadAccess[*generated.Subscriptio](), +// ), +// policy.WithMutationRules( +// entfga.CheckEditAccess[*generated.ContactMutation](), +// ), +// ) +//} +// diff --git a/internal/ent/schema/orgsubscription_history.go b/internal/ent/schema/orgsubscription_history.go new file mode 100644 index 00000000..1f9a0c77 --- /dev/null +++ b/internal/ent/schema/orgsubscription_history.go @@ -0,0 +1,90 @@ +// Code generated by entx.history, DO NOT EDIT. +package schema + +import ( + "time" + + "entgo.io/contrib/entgql" + "entgo.io/ent" + "entgo.io/ent/dialect/entsql" + "entgo.io/ent/schema" + "entgo.io/ent/schema/field" + "entgo.io/ent/schema/index" + + "github.com/theopenlane/entx" + "github.com/theopenlane/entx/history" +) + +// OrgSubscriptionHistory holds the schema definition for the OrgSubscriptionHistory entity. +type OrgSubscriptionHistory struct { + ent.Schema +} + +// Annotations of the OrgSubscriptionHistory. +func (OrgSubscriptionHistory) Annotations() []schema.Annotation { + return []schema.Annotation{ + entx.SchemaGenSkip(true), + entsql.Annotation{ + Table: "org_subscription_history", + }, + history.Annotations{ + IsHistory: true, + Exclude: true, + }, + entgql.QueryField(), + entgql.RelayConnection(), + } +} + +// Fields of the OrgSubscriptionHistory. +func (OrgSubscriptionHistory) Fields() []ent.Field { + historyFields := []ent.Field{ + field.Time("history_time"). + Default(time.Now). + Immutable(), + field.String("ref"). + Immutable(). + Optional(), + field.Enum("operation"). + GoType(history.OpType("")). + Immutable(), + } + + // get the fields from the mixins + // we only want to include mixin fields, not edges + // so this prevents FKs back to the main tables + mixins := OrgSubscription{}.Mixin() + for _, mixin := range mixins { + for _, field := range mixin.Fields() { + // make sure the mixed in fields do not have unique constraints + field.Descriptor().Unique = false + + // make sure the mixed in fields do not have validators + field.Descriptor().Validators = nil + + // append the mixed in field to the history fields + historyFields = append(historyFields, field) + } + } + + original := OrgSubscription{} + for _, field := range original.Fields() { + // make sure the fields do not have unique constraints + field.Descriptor().Unique = false + + // make sure the mixed in fields do not have validators + field.Descriptor().Validators = nil + + // append the field to the history fields + historyFields = append(historyFields, field) + } + + return historyFields +} + +// Indexes of the OrgSubscriptionHistory +func (OrgSubscriptionHistory) Indexes() []ent.Index { + return []ent.Index{ + index.Fields("history_time"), + } +} diff --git a/internal/graphapi/adminsearch.resolvers.go b/internal/graphapi/adminsearch.resolvers.go index beaa34c6..c369cd5a 100644 --- a/internal/graphapi/adminsearch.resolvers.go +++ b/internal/graphapi/adminsearch.resolvers.go @@ -38,6 +38,7 @@ func (r *queryResolver) AdminSearch(ctx context.Context, query string) (*SearchR narrativeResults []*generated.Narrative oauthproviderResults []*generated.OauthProvider ohauthtootokenResults []*generated.OhAuthTooToken + orgsubscriptionResults []*generated.OrgSubscription organizationResults []*generated.Organization organizationsettingResults []*generated.OrganizationSetting personalaccesstokenResults []*generated.PersonalAccessToken @@ -203,6 +204,13 @@ func (r *queryResolver) AdminSearch(ctx context.Context, query string) (*SearchR errors = append(errors, err) } }, + func() { + var err error + orgsubscriptionResults, err = searchOrgSubscriptions(ctx, query) + if err != nil { + errors = append(errors, err) + } + }, func() { var err error organizationResults, err = searchOrganizations(ctx, query) @@ -383,6 +391,9 @@ func (r *queryResolver) AdminSearch(ctx context.Context, query string) (*SearchR OhAuthTooTokenSearchResult{ OhAuthTooTokens: ohauthtootokenResults, }, + OrgSubscriptionSearchResult{ + OrgSubscriptions: orgsubscriptionResults, + }, OrganizationSearchResult{ Organizations: organizationResults, }, @@ -683,6 +694,18 @@ func (r *queryResolver) AdminOhAuthTooTokenSearch(ctx context.Context, query str OhAuthTooTokens: ohauthtootokenResults, }, nil } +func (r *queryResolver) AdminOrgSubscriptionSearch(ctx context.Context, query string) (*OrgSubscriptionSearchResult, error) { + orgsubscriptionResults, err := adminSearchOrgSubscriptions(ctx, query) + + if err != nil { + return nil, ErrSearchFailed + } + + // return the results + return &OrgSubscriptionSearchResult{ + OrgSubscriptions: orgsubscriptionResults, + }, nil +} func (r *queryResolver) AdminOrganizationSearch(ctx context.Context, query string) (*OrganizationSearchResult, error) { organizationResults, err := adminSearchOrganizations(ctx, query) diff --git a/internal/graphapi/bulk.go b/internal/graphapi/bulk.go index f6c9aea4..b709b0bb 100644 --- a/internal/graphapi/bulk.go +++ b/internal/graphapi/bulk.go @@ -502,6 +502,25 @@ func (r *mutationResolver) bulkCreateOrgMembership(ctx context.Context, input [] }, nil } +// bulkCreateOrgSubscription uses the CreateBulk function to create multiple OrgSubscription entities +func (r *mutationResolver) bulkCreateOrgSubscription(ctx context.Context, input []*generated.CreateOrgSubscriptionInput) (*OrgSubscriptionBulkCreatePayload, error) { + c := withTransactionalMutation(ctx) + builders := make([]*generated.OrgSubscriptionCreate, len(input)) + for i, data := range input { + builders[i] = c.OrgSubscription.Create().SetInput(*data) + } + + res, err := c.OrgSubscription.CreateBulk(builders...).Save(ctx) + if err != nil { + return nil, parseRequestError(err, action{action: ActionCreate, object: "orgsubscription"}) + } + + // return response + return &OrgSubscriptionBulkCreatePayload{ + OrgSubscriptions: res, + }, nil +} + // bulkCreatePersonalAccessToken uses the CreateBulk function to create multiple PersonalAccessToken entities func (r *mutationResolver) bulkCreatePersonalAccessToken(ctx context.Context, input []*generated.CreatePersonalAccessTokenInput) (*PersonalAccessTokenBulkCreatePayload, error) { c := withTransactionalMutation(ctx) diff --git a/internal/graphapi/ent.resolvers.go b/internal/graphapi/ent.resolvers.go index 67d73eb0..dac96151 100644 --- a/internal/graphapi/ent.resolvers.go +++ b/internal/graphapi/ent.resolvers.go @@ -825,6 +825,38 @@ func (r *queryResolver) OrgMembershipHistories(ctx context.Context, after *entgq return res, err } +// OrgSubscriptions is the resolver for the orgSubscriptions field. +func (r *queryResolver) OrgSubscriptions(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgSubscriptionWhereInput) (*generated.OrgSubscriptionConnection, error) { + res, err := withTransactionalMutation(ctx).OrgSubscription.Query().Paginate( + ctx, + after, + first, + before, + last, + generated.WithOrgSubscriptionFilter(where.Filter)) + if err != nil { + return nil, parseRequestError(err, action{action: ActionGet, object: "orgsubscription"}) + } + + return res, err +} + +// OrgSubscriptionHistories is the resolver for the orgSubscriptionHistories field. +func (r *queryResolver) OrgSubscriptionHistories(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgSubscriptionHistoryWhereInput) (*generated.OrgSubscriptionHistoryConnection, error) { + res, err := withTransactionalMutation(ctx).OrgSubscriptionHistory.Query().Paginate( + ctx, + after, + first, + before, + last, + generated.WithOrgSubscriptionHistoryFilter(where.Filter)) + if err != nil { + return nil, parseRequestError(err, action{action: ActionGet, object: "orgsubscriptionhistory"}) + } + + return res, err +} + // Organizations is the resolver for the organizations field. func (r *queryResolver) Organizations(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, orderBy *generated.OrganizationOrder, where *generated.OrganizationWhereInput) (*generated.OrganizationConnection, error) { res, err := withTransactionalMutation(ctx).Organization.Query().Paginate( diff --git a/internal/graphapi/gen_models.go b/internal/graphapi/gen_models.go index a54798db..c9144c5d 100644 --- a/internal/graphapi/gen_models.go +++ b/internal/graphapi/gen_models.go @@ -785,6 +785,36 @@ type OrgMembershipUpdatePayload struct { OrgMembership *generated.OrgMembership `json:"orgMembership"` } +// Return response for createBulkOrgSubscription mutation +type OrgSubscriptionBulkCreatePayload struct { + // Created orgSubscriptions + OrgSubscriptions []*generated.OrgSubscription `json:"orgSubscriptions,omitempty"` +} + +// Return response for createOrgSubscription mutation +type OrgSubscriptionCreatePayload struct { + // Created orgSubscription + OrgSubscription *generated.OrgSubscription `json:"orgSubscription"` +} + +// Return response for deleteOrgSubscription mutation +type OrgSubscriptionDeletePayload struct { + // Deleted orgSubscription ID + DeletedID string `json:"deletedID"` +} + +type OrgSubscriptionSearchResult struct { + OrgSubscriptions []*generated.OrgSubscription `json:"orgSubscriptions,omitempty"` +} + +func (OrgSubscriptionSearchResult) IsSearchResult() {} + +// Return response for updateOrgSubscription mutation +type OrgSubscriptionUpdatePayload struct { + // Updated orgSubscription + OrgSubscription *generated.OrgSubscription `json:"orgSubscription"` +} + // Return response for createBulkOrganization mutation type OrganizationBulkCreatePayload struct { // Created organizations diff --git a/internal/graphapi/gen_server.go b/internal/graphapi/gen_server.go index 9f7b3a4c..1dba55f8 100644 --- a/internal/graphapi/gen_server.go +++ b/internal/graphapi/gen_server.go @@ -1861,6 +1861,7 @@ type ComplexityRoot struct { CreateBulkCSVOauthProvider func(childComplexity int, input graphql.Upload) int CreateBulkCSVOhAuthTooToken func(childComplexity int, input graphql.Upload) int CreateBulkCSVOrgMembership func(childComplexity int, input graphql.Upload) int + CreateBulkCSVOrgSubscription func(childComplexity int, input graphql.Upload) int CreateBulkCSVOrganization func(childComplexity int, input graphql.Upload) int CreateBulkCSVOrganizationSetting func(childComplexity int, input graphql.Upload) int CreateBulkCSVPersonalAccessToken func(childComplexity int, input graphql.Upload) int @@ -1897,6 +1898,7 @@ type ComplexityRoot struct { CreateBulkOauthProvider func(childComplexity int, input []*generated.CreateOauthProviderInput) int CreateBulkOhAuthTooToken func(childComplexity int, input []*generated.CreateOhAuthTooTokenInput) int CreateBulkOrgMembership func(childComplexity int, input []*generated.CreateOrgMembershipInput) int + CreateBulkOrgSubscription func(childComplexity int, input []*generated.CreateOrgSubscriptionInput) int CreateBulkOrganization func(childComplexity int, input []*generated.CreateOrganizationInput) int CreateBulkOrganizationSetting func(childComplexity int, input []*generated.CreateOrganizationSettingInput) int CreateBulkPersonalAccessToken func(childComplexity int, input []*generated.CreatePersonalAccessTokenInput) int @@ -1935,6 +1937,7 @@ type ComplexityRoot struct { CreateOauthProvider func(childComplexity int, input generated.CreateOauthProviderInput) int CreateOhAuthTooToken func(childComplexity int, input generated.CreateOhAuthTooTokenInput) int CreateOrgMembership func(childComplexity int, input generated.CreateOrgMembershipInput) int + CreateOrgSubscription func(childComplexity int, input generated.CreateOrgSubscriptionInput) int CreateOrganization func(childComplexity int, input generated.CreateOrganizationInput) int CreateOrganizationSetting func(childComplexity int, input generated.CreateOrganizationSettingInput) int CreatePersonalAccessToken func(childComplexity int, input generated.CreatePersonalAccessTokenInput) int @@ -1977,6 +1980,7 @@ type ComplexityRoot struct { DeleteOauthProvider func(childComplexity int, id string) int DeleteOhAuthTooToken func(childComplexity int, id string) int DeleteOrgMembership func(childComplexity int, id string) int + DeleteOrgSubscription func(childComplexity int, id string) int DeleteOrganization func(childComplexity int, id string) int DeleteOrganizationSetting func(childComplexity int, id string) int DeletePersonalAccessToken func(childComplexity int, id string) int @@ -2015,6 +2019,7 @@ type ComplexityRoot struct { UpdateOauthProvider func(childComplexity int, id string, input generated.UpdateOauthProviderInput) int UpdateOhAuthTooToken func(childComplexity int, id string, input generated.UpdateOhAuthTooTokenInput) int UpdateOrgMembership func(childComplexity int, id string, input generated.UpdateOrgMembershipInput) int + UpdateOrgSubscription func(childComplexity int, id string, input generated.UpdateOrgSubscriptionInput) int UpdateOrganization func(childComplexity int, id string, input generated.UpdateOrganizationInput) int UpdateOrganizationSetting func(childComplexity int, id string, input generated.UpdateOrganizationSettingInput) int UpdatePersonalAccessToken func(childComplexity int, id string, input generated.UpdatePersonalAccessTokenInput) int @@ -2382,6 +2387,92 @@ type ComplexityRoot struct { OrgMembership func(childComplexity int) int } + OrgSubscription struct { + Active func(childComplexity int) int + CreatedAt func(childComplexity int) int + CreatedBy func(childComplexity int) int + DeletedAt func(childComplexity int) int + DeletedBy func(childComplexity int) int + ExpiresAt func(childComplexity int) int + Features func(childComplexity int) int + ID func(childComplexity int) int + Owner func(childComplexity int) int + OwnerID func(childComplexity int) int + ProductTier func(childComplexity int) int + StripeCustomerID func(childComplexity int) int + StripeProductTierID func(childComplexity int) int + StripeSubscriptionID func(childComplexity int) int + StripeSubscriptionStatus func(childComplexity int) int + Tags func(childComplexity int) int + UpdatedAt func(childComplexity int) int + UpdatedBy func(childComplexity int) int + } + + OrgSubscriptionBulkCreatePayload struct { + OrgSubscriptions func(childComplexity int) int + } + + OrgSubscriptionConnection struct { + Edges func(childComplexity int) int + PageInfo func(childComplexity int) int + TotalCount func(childComplexity int) int + } + + OrgSubscriptionCreatePayload struct { + OrgSubscription func(childComplexity int) int + } + + OrgSubscriptionDeletePayload struct { + DeletedID func(childComplexity int) int + } + + OrgSubscriptionEdge struct { + Cursor func(childComplexity int) int + Node func(childComplexity int) int + } + + OrgSubscriptionHistory struct { + Active func(childComplexity int) int + CreatedAt func(childComplexity int) int + CreatedBy func(childComplexity int) int + DeletedAt func(childComplexity int) int + DeletedBy func(childComplexity int) int + ExpiresAt func(childComplexity int) int + Features func(childComplexity int) int + HistoryTime func(childComplexity int) int + ID func(childComplexity int) int + Operation func(childComplexity int) int + OwnerID func(childComplexity int) int + ProductTier func(childComplexity int) int + Ref func(childComplexity int) int + StripeCustomerID func(childComplexity int) int + StripeProductTierID func(childComplexity int) int + StripeSubscriptionID func(childComplexity int) int + StripeSubscriptionStatus func(childComplexity int) int + Tags func(childComplexity int) int + UpdatedAt func(childComplexity int) int + UpdatedBy func(childComplexity int) int + } + + OrgSubscriptionHistoryConnection struct { + Edges func(childComplexity int) int + PageInfo func(childComplexity int) int + TotalCount func(childComplexity int) int + } + + OrgSubscriptionHistoryEdge struct { + Cursor func(childComplexity int) int + Node func(childComplexity int) int + } + + OrgSubscriptionSearchResult struct { + OrgSubscriptions func(childComplexity int) int + } + + OrgSubscriptionUpdatePayload struct { + OrgSubscription func(childComplexity int) int + } + Organization struct { APITokens func(childComplexity int) int AvatarRemoteURL func(childComplexity int) int @@ -2421,6 +2512,7 @@ type ComplexityRoot struct { Notes func(childComplexity int) int Oauthprovider func(childComplexity int) int OrganizationEntitlement func(childComplexity int) int + Orgsubscriptions func(childComplexity int) int Parent func(childComplexity int) int PersonalAccessTokens func(childComplexity int) int PersonalOrg func(childComplexity int) int @@ -2948,6 +3040,7 @@ type ComplexityRoot struct { AdminNarrativeSearch func(childComplexity int, query string) int AdminOauthProviderSearch func(childComplexity int, query string) int AdminOhAuthTooTokenSearch func(childComplexity int, query string) int + AdminOrgSubscriptionSearch func(childComplexity int, query string) int AdminOrganizationSearch func(childComplexity int, query string) int AdminOrganizationSettingSearch func(childComplexity int, query string) int AdminPersonalAccessTokenSearch func(childComplexity int, query string) int @@ -3055,6 +3148,10 @@ type ComplexityRoot struct { OrgMembership func(childComplexity int, id string) int OrgMembershipHistories func(childComplexity int, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgMembershipHistoryWhereInput) int OrgMemberships func(childComplexity int, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgMembershipWhereInput) int + OrgSubscription func(childComplexity int, id string) int + OrgSubscriptionHistories func(childComplexity int, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgSubscriptionHistoryWhereInput) int + OrgSubscriptionSearch func(childComplexity int, query string) int + OrgSubscriptions func(childComplexity int, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgSubscriptionWhereInput) int Organization func(childComplexity int, id string) int OrganizationHistories func(childComplexity int, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, orderBy *generated.OrganizationHistoryOrder, where *generated.OrganizationHistoryWhereInput) int OrganizationSearch func(childComplexity int, query string) int @@ -4087,6 +4184,11 @@ type MutationResolver interface { CreateBulkCSVOrgMembership(ctx context.Context, input graphql.Upload) (*OrgMembershipBulkCreatePayload, error) UpdateOrgMembership(ctx context.Context, id string, input generated.UpdateOrgMembershipInput) (*OrgMembershipUpdatePayload, error) DeleteOrgMembership(ctx context.Context, id string) (*OrgMembershipDeletePayload, error) + CreateOrgSubscription(ctx context.Context, input generated.CreateOrgSubscriptionInput) (*OrgSubscriptionCreatePayload, error) + CreateBulkOrgSubscription(ctx context.Context, input []*generated.CreateOrgSubscriptionInput) (*OrgSubscriptionBulkCreatePayload, error) + CreateBulkCSVOrgSubscription(ctx context.Context, input graphql.Upload) (*OrgSubscriptionBulkCreatePayload, error) + UpdateOrgSubscription(ctx context.Context, id string, input generated.UpdateOrgSubscriptionInput) (*OrgSubscriptionUpdatePayload, error) + DeleteOrgSubscription(ctx context.Context, id string) (*OrgSubscriptionDeletePayload, error) CreatePersonalAccessToken(ctx context.Context, input generated.CreatePersonalAccessTokenInput) (*PersonalAccessTokenCreatePayload, error) CreateBulkPersonalAccessToken(ctx context.Context, input []*generated.CreatePersonalAccessTokenInput) (*PersonalAccessTokenBulkCreatePayload, error) CreateBulkCSVPersonalAccessToken(ctx context.Context, input graphql.Upload) (*PersonalAccessTokenBulkCreatePayload, error) @@ -4207,6 +4309,8 @@ type QueryResolver interface { OhAuthTooTokens(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OhAuthTooTokenWhereInput) (*generated.OhAuthTooTokenConnection, error) OrgMemberships(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgMembershipWhereInput) (*generated.OrgMembershipConnection, error) OrgMembershipHistories(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgMembershipHistoryWhereInput) (*generated.OrgMembershipHistoryConnection, error) + OrgSubscriptions(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgSubscriptionWhereInput) (*generated.OrgSubscriptionConnection, error) + OrgSubscriptionHistories(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrgSubscriptionHistoryWhereInput) (*generated.OrgSubscriptionHistoryConnection, error) Organizations(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, orderBy *generated.OrganizationOrder, where *generated.OrganizationWhereInput) (*generated.OrganizationConnection, error) OrganizationHistories(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, orderBy *generated.OrganizationHistoryOrder, where *generated.OrganizationHistoryWhereInput) (*generated.OrganizationHistoryConnection, error) OrganizationSettings(ctx context.Context, after *entgql.Cursor[string], first *int, before *entgql.Cursor[string], last *int, where *generated.OrganizationSettingWhereInput) (*generated.OrganizationSettingConnection, error) @@ -4258,6 +4362,7 @@ type QueryResolver interface { AdminNarrativeSearch(ctx context.Context, query string) (*NarrativeSearchResult, error) AdminOauthProviderSearch(ctx context.Context, query string) (*OauthProviderSearchResult, error) AdminOhAuthTooTokenSearch(ctx context.Context, query string) (*OhAuthTooTokenSearchResult, error) + AdminOrgSubscriptionSearch(ctx context.Context, query string) (*OrgSubscriptionSearchResult, error) AdminOrganizationSearch(ctx context.Context, query string) (*OrganizationSearchResult, error) AdminOrganizationSettingSearch(ctx context.Context, query string) (*OrganizationSettingSearchResult, error) AdminPersonalAccessTokenSearch(ctx context.Context, query string) (*PersonalAccessTokenSearchResult, error) @@ -4300,6 +4405,7 @@ type QueryResolver interface { Organization(ctx context.Context, id string) (*generated.Organization, error) OrganizationSetting(ctx context.Context, id string) (*generated.OrganizationSetting, error) OrgMembership(ctx context.Context, id string) (*generated.OrgMembership, error) + OrgSubscription(ctx context.Context, id string) (*generated.OrgSubscription, error) PersonalAccessToken(ctx context.Context, id string) (*generated.PersonalAccessToken, error) Procedure(ctx context.Context, id string) (*generated.Procedure, error) Program(ctx context.Context, id string) (*generated.Program, error) @@ -4326,6 +4432,7 @@ type QueryResolver interface { NarrativeSearch(ctx context.Context, query string) (*NarrativeSearchResult, error) OauthProviderSearch(ctx context.Context, query string) (*OauthProviderSearchResult, error) OhAuthTooTokenSearch(ctx context.Context, query string) (*OhAuthTooTokenSearchResult, error) + OrgSubscriptionSearch(ctx context.Context, query string) (*OrgSubscriptionSearchResult, error) OrganizationSearch(ctx context.Context, query string) (*OrganizationSearchResult, error) OrganizationSettingSearch(ctx context.Context, query string) (*OrganizationSettingSearchResult, error) PersonalAccessTokenSearch(ctx context.Context, query string) (*PersonalAccessTokenSearchResult, error) @@ -12485,6 +12592,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Mutation.CreateBulkCSVOrgMembership(childComplexity, args["input"].(graphql.Upload)), true + case "Mutation.createBulkCSVOrgSubscription": + if e.complexity.Mutation.CreateBulkCSVOrgSubscription == nil { + break + } + + args, err := ec.field_Mutation_createBulkCSVOrgSubscription_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Mutation.CreateBulkCSVOrgSubscription(childComplexity, args["input"].(graphql.Upload)), true + case "Mutation.createBulkCSVOrganization": if e.complexity.Mutation.CreateBulkCSVOrganization == nil { break @@ -12917,6 +13036,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Mutation.CreateBulkOrgMembership(childComplexity, args["input"].([]*generated.CreateOrgMembershipInput)), true + case "Mutation.createBulkOrgSubscription": + if e.complexity.Mutation.CreateBulkOrgSubscription == nil { + break + } + + args, err := ec.field_Mutation_createBulkOrgSubscription_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Mutation.CreateBulkOrgSubscription(childComplexity, args["input"].([]*generated.CreateOrgSubscriptionInput)), true + case "Mutation.createBulkOrganization": if e.complexity.Mutation.CreateBulkOrganization == nil { break @@ -13373,6 +13504,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Mutation.CreateOrgMembership(childComplexity, args["input"].(generated.CreateOrgMembershipInput)), true + case "Mutation.createOrgSubscription": + if e.complexity.Mutation.CreateOrgSubscription == nil { + break + } + + args, err := ec.field_Mutation_createOrgSubscription_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Mutation.CreateOrgSubscription(childComplexity, args["input"].(generated.CreateOrgSubscriptionInput)), true + case "Mutation.createOrganization": if e.complexity.Mutation.CreateOrganization == nil { break @@ -13877,6 +14020,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Mutation.DeleteOrgMembership(childComplexity, args["id"].(string)), true + case "Mutation.deleteOrgSubscription": + if e.complexity.Mutation.DeleteOrgSubscription == nil { + break + } + + args, err := ec.field_Mutation_deleteOrgSubscription_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Mutation.DeleteOrgSubscription(childComplexity, args["id"].(string)), true + case "Mutation.deleteOrganization": if e.complexity.Mutation.DeleteOrganization == nil { break @@ -14333,6 +14488,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Mutation.UpdateOrgMembership(childComplexity, args["id"].(string), args["input"].(generated.UpdateOrgMembershipInput)), true + case "Mutation.updateOrgSubscription": + if e.complexity.Mutation.UpdateOrgSubscription == nil { + break + } + + args, err := ec.field_Mutation_updateOrgSubscription_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Mutation.UpdateOrgSubscription(childComplexity, args["id"].(string), args["input"].(generated.UpdateOrgSubscriptionInput)), true + case "Mutation.updateOrganization": if e.complexity.Mutation.UpdateOrganization == nil { break @@ -16002,6 +16169,377 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.OrgMembershipUpdatePayload.OrgMembership(childComplexity), true + case "OrgSubscription.active": + if e.complexity.OrgSubscription.Active == nil { + break + } + + return e.complexity.OrgSubscription.Active(childComplexity), true + + case "OrgSubscription.createdAt": + if e.complexity.OrgSubscription.CreatedAt == nil { + break + } + + return e.complexity.OrgSubscription.CreatedAt(childComplexity), true + + case "OrgSubscription.createdBy": + if e.complexity.OrgSubscription.CreatedBy == nil { + break + } + + return e.complexity.OrgSubscription.CreatedBy(childComplexity), true + + case "OrgSubscription.deletedAt": + if e.complexity.OrgSubscription.DeletedAt == nil { + break + } + + return e.complexity.OrgSubscription.DeletedAt(childComplexity), true + + case "OrgSubscription.deletedBy": + if e.complexity.OrgSubscription.DeletedBy == nil { + break + } + + return e.complexity.OrgSubscription.DeletedBy(childComplexity), true + + case "OrgSubscription.expiresAt": + if e.complexity.OrgSubscription.ExpiresAt == nil { + break + } + + return e.complexity.OrgSubscription.ExpiresAt(childComplexity), true + + case "OrgSubscription.features": + if e.complexity.OrgSubscription.Features == nil { + break + } + + return e.complexity.OrgSubscription.Features(childComplexity), true + + case "OrgSubscription.id": + if e.complexity.OrgSubscription.ID == nil { + break + } + + return e.complexity.OrgSubscription.ID(childComplexity), true + + case "OrgSubscription.owner": + if e.complexity.OrgSubscription.Owner == nil { + break + } + + return e.complexity.OrgSubscription.Owner(childComplexity), true + + case "OrgSubscription.ownerID": + if e.complexity.OrgSubscription.OwnerID == nil { + break + } + + return e.complexity.OrgSubscription.OwnerID(childComplexity), true + + case "OrgSubscription.productTier": + if e.complexity.OrgSubscription.ProductTier == nil { + break + } + + return e.complexity.OrgSubscription.ProductTier(childComplexity), true + + case "OrgSubscription.stripeCustomerID": + if e.complexity.OrgSubscription.StripeCustomerID == nil { + break + } + + return e.complexity.OrgSubscription.StripeCustomerID(childComplexity), true + + case "OrgSubscription.stripeProductTierID": + if e.complexity.OrgSubscription.StripeProductTierID == nil { + break + } + + return e.complexity.OrgSubscription.StripeProductTierID(childComplexity), true + + case "OrgSubscription.stripeSubscriptionID": + if e.complexity.OrgSubscription.StripeSubscriptionID == nil { + break + } + + return e.complexity.OrgSubscription.StripeSubscriptionID(childComplexity), true + + case "OrgSubscription.stripeSubscriptionStatus": + if e.complexity.OrgSubscription.StripeSubscriptionStatus == nil { + break + } + + return e.complexity.OrgSubscription.StripeSubscriptionStatus(childComplexity), true + + case "OrgSubscription.tags": + if e.complexity.OrgSubscription.Tags == nil { + break + } + + return e.complexity.OrgSubscription.Tags(childComplexity), true + + case "OrgSubscription.updatedAt": + if e.complexity.OrgSubscription.UpdatedAt == nil { + break + } + + return e.complexity.OrgSubscription.UpdatedAt(childComplexity), true + + case "OrgSubscription.updatedBy": + if e.complexity.OrgSubscription.UpdatedBy == nil { + break + } + + return e.complexity.OrgSubscription.UpdatedBy(childComplexity), true + + case "OrgSubscriptionBulkCreatePayload.orgSubscriptions": + if e.complexity.OrgSubscriptionBulkCreatePayload.OrgSubscriptions == nil { + break + } + + return e.complexity.OrgSubscriptionBulkCreatePayload.OrgSubscriptions(childComplexity), true + + case "OrgSubscriptionConnection.edges": + if e.complexity.OrgSubscriptionConnection.Edges == nil { + break + } + + return e.complexity.OrgSubscriptionConnection.Edges(childComplexity), true + + case "OrgSubscriptionConnection.pageInfo": + if e.complexity.OrgSubscriptionConnection.PageInfo == nil { + break + } + + return e.complexity.OrgSubscriptionConnection.PageInfo(childComplexity), true + + case "OrgSubscriptionConnection.totalCount": + if e.complexity.OrgSubscriptionConnection.TotalCount == nil { + break + } + + return e.complexity.OrgSubscriptionConnection.TotalCount(childComplexity), true + + case "OrgSubscriptionCreatePayload.orgSubscription": + if e.complexity.OrgSubscriptionCreatePayload.OrgSubscription == nil { + break + } + + return e.complexity.OrgSubscriptionCreatePayload.OrgSubscription(childComplexity), true + + case "OrgSubscriptionDeletePayload.deletedID": + if e.complexity.OrgSubscriptionDeletePayload.DeletedID == nil { + break + } + + return e.complexity.OrgSubscriptionDeletePayload.DeletedID(childComplexity), true + + case "OrgSubscriptionEdge.cursor": + if e.complexity.OrgSubscriptionEdge.Cursor == nil { + break + } + + return e.complexity.OrgSubscriptionEdge.Cursor(childComplexity), true + + case "OrgSubscriptionEdge.node": + if e.complexity.OrgSubscriptionEdge.Node == nil { + break + } + + return e.complexity.OrgSubscriptionEdge.Node(childComplexity), true + + case "OrgSubscriptionHistory.active": + if e.complexity.OrgSubscriptionHistory.Active == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.Active(childComplexity), true + + case "OrgSubscriptionHistory.createdAt": + if e.complexity.OrgSubscriptionHistory.CreatedAt == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.CreatedAt(childComplexity), true + + case "OrgSubscriptionHistory.createdBy": + if e.complexity.OrgSubscriptionHistory.CreatedBy == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.CreatedBy(childComplexity), true + + case "OrgSubscriptionHistory.deletedAt": + if e.complexity.OrgSubscriptionHistory.DeletedAt == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.DeletedAt(childComplexity), true + + case "OrgSubscriptionHistory.deletedBy": + if e.complexity.OrgSubscriptionHistory.DeletedBy == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.DeletedBy(childComplexity), true + + case "OrgSubscriptionHistory.expiresAt": + if e.complexity.OrgSubscriptionHistory.ExpiresAt == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.ExpiresAt(childComplexity), true + + case "OrgSubscriptionHistory.features": + if e.complexity.OrgSubscriptionHistory.Features == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.Features(childComplexity), true + + case "OrgSubscriptionHistory.historyTime": + if e.complexity.OrgSubscriptionHistory.HistoryTime == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.HistoryTime(childComplexity), true + + case "OrgSubscriptionHistory.id": + if e.complexity.OrgSubscriptionHistory.ID == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.ID(childComplexity), true + + case "OrgSubscriptionHistory.operation": + if e.complexity.OrgSubscriptionHistory.Operation == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.Operation(childComplexity), true + + case "OrgSubscriptionHistory.ownerID": + if e.complexity.OrgSubscriptionHistory.OwnerID == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.OwnerID(childComplexity), true + + case "OrgSubscriptionHistory.productTier": + if e.complexity.OrgSubscriptionHistory.ProductTier == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.ProductTier(childComplexity), true + + case "OrgSubscriptionHistory.ref": + if e.complexity.OrgSubscriptionHistory.Ref == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.Ref(childComplexity), true + + case "OrgSubscriptionHistory.stripeCustomerID": + if e.complexity.OrgSubscriptionHistory.StripeCustomerID == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.StripeCustomerID(childComplexity), true + + case "OrgSubscriptionHistory.stripeProductTierID": + if e.complexity.OrgSubscriptionHistory.StripeProductTierID == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.StripeProductTierID(childComplexity), true + + case "OrgSubscriptionHistory.stripeSubscriptionID": + if e.complexity.OrgSubscriptionHistory.StripeSubscriptionID == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.StripeSubscriptionID(childComplexity), true + + case "OrgSubscriptionHistory.stripeSubscriptionStatus": + if e.complexity.OrgSubscriptionHistory.StripeSubscriptionStatus == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.StripeSubscriptionStatus(childComplexity), true + + case "OrgSubscriptionHistory.tags": + if e.complexity.OrgSubscriptionHistory.Tags == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.Tags(childComplexity), true + + case "OrgSubscriptionHistory.updatedAt": + if e.complexity.OrgSubscriptionHistory.UpdatedAt == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.UpdatedAt(childComplexity), true + + case "OrgSubscriptionHistory.updatedBy": + if e.complexity.OrgSubscriptionHistory.UpdatedBy == nil { + break + } + + return e.complexity.OrgSubscriptionHistory.UpdatedBy(childComplexity), true + + case "OrgSubscriptionHistoryConnection.edges": + if e.complexity.OrgSubscriptionHistoryConnection.Edges == nil { + break + } + + return e.complexity.OrgSubscriptionHistoryConnection.Edges(childComplexity), true + + case "OrgSubscriptionHistoryConnection.pageInfo": + if e.complexity.OrgSubscriptionHistoryConnection.PageInfo == nil { + break + } + + return e.complexity.OrgSubscriptionHistoryConnection.PageInfo(childComplexity), true + + case "OrgSubscriptionHistoryConnection.totalCount": + if e.complexity.OrgSubscriptionHistoryConnection.TotalCount == nil { + break + } + + return e.complexity.OrgSubscriptionHistoryConnection.TotalCount(childComplexity), true + + case "OrgSubscriptionHistoryEdge.cursor": + if e.complexity.OrgSubscriptionHistoryEdge.Cursor == nil { + break + } + + return e.complexity.OrgSubscriptionHistoryEdge.Cursor(childComplexity), true + + case "OrgSubscriptionHistoryEdge.node": + if e.complexity.OrgSubscriptionHistoryEdge.Node == nil { + break + } + + return e.complexity.OrgSubscriptionHistoryEdge.Node(childComplexity), true + + case "OrgSubscriptionSearchResult.orgSubscriptions": + if e.complexity.OrgSubscriptionSearchResult.OrgSubscriptions == nil { + break + } + + return e.complexity.OrgSubscriptionSearchResult.OrgSubscriptions(childComplexity), true + + case "OrgSubscriptionUpdatePayload.orgSubscription": + if e.complexity.OrgSubscriptionUpdatePayload.OrgSubscription == nil { + break + } + + return e.complexity.OrgSubscriptionUpdatePayload.OrgSubscription(childComplexity), true + case "Organization.apiTokens": if e.complexity.Organization.APITokens == nil { break @@ -16273,6 +16811,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Organization.OrganizationEntitlement(childComplexity), true + case "Organization.orgsubscriptions": + if e.complexity.Organization.Orgsubscriptions == nil { + break + } + + return e.complexity.Organization.Orgsubscriptions(childComplexity), true + case "Organization.parent": if e.complexity.Organization.Parent == nil { break @@ -18779,6 +19324,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Query.AdminOhAuthTooTokenSearch(childComplexity, args["query"].(string)), true + case "Query.adminOrgSubscriptionSearch": + if e.complexity.Query.AdminOrgSubscriptionSearch == nil { + break + } + + args, err := ec.field_Query_adminOrgSubscriptionSearch_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Query.AdminOrgSubscriptionSearch(childComplexity, args["query"].(string)), true + case "Query.adminOrganizationSearch": if e.complexity.Query.AdminOrganizationSearch == nil { break @@ -20063,6 +20620,54 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Query.OrgMemberships(childComplexity, args["after"].(*entgql.Cursor[string]), args["first"].(*int), args["before"].(*entgql.Cursor[string]), args["last"].(*int), args["where"].(*generated.OrgMembershipWhereInput)), true + case "Query.orgSubscription": + if e.complexity.Query.OrgSubscription == nil { + break + } + + args, err := ec.field_Query_orgSubscription_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Query.OrgSubscription(childComplexity, args["id"].(string)), true + + case "Query.orgSubscriptionHistories": + if e.complexity.Query.OrgSubscriptionHistories == nil { + break + } + + args, err := ec.field_Query_orgSubscriptionHistories_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Query.OrgSubscriptionHistories(childComplexity, args["after"].(*entgql.Cursor[string]), args["first"].(*int), args["before"].(*entgql.Cursor[string]), args["last"].(*int), args["where"].(*generated.OrgSubscriptionHistoryWhereInput)), true + + case "Query.orgSubscriptionSearch": + if e.complexity.Query.OrgSubscriptionSearch == nil { + break + } + + args, err := ec.field_Query_orgSubscriptionSearch_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Query.OrgSubscriptionSearch(childComplexity, args["query"].(string)), true + + case "Query.orgSubscriptions": + if e.complexity.Query.OrgSubscriptions == nil { + break + } + + args, err := ec.field_Query_orgSubscriptions_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Query.OrgSubscriptions(childComplexity, args["after"].(*entgql.Cursor[string]), args["first"].(*int), args["before"].(*entgql.Cursor[string]), args["last"].(*int), args["where"].(*generated.OrgSubscriptionWhereInput)), true + case "Query.organization": if e.complexity.Query.Organization == nil { break @@ -24552,6 +25157,7 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputCreateOauthProviderInput, ec.unmarshalInputCreateOhAuthTooTokenInput, ec.unmarshalInputCreateOrgMembershipInput, + ec.unmarshalInputCreateOrgSubscriptionInput, ec.unmarshalInputCreateOrganizationInput, ec.unmarshalInputCreateOrganizationSettingInput, ec.unmarshalInputCreatePersonalAccessTokenInput, @@ -24619,6 +25225,8 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputOhAuthTooTokenWhereInput, ec.unmarshalInputOrgMembershipHistoryWhereInput, ec.unmarshalInputOrgMembershipWhereInput, + ec.unmarshalInputOrgSubscriptionHistoryWhereInput, + ec.unmarshalInputOrgSubscriptionWhereInput, ec.unmarshalInputOrganizationHistoryOrder, ec.unmarshalInputOrganizationHistoryWhereInput, ec.unmarshalInputOrganizationOrder, @@ -24672,6 +25280,7 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputUpdateOauthProviderInput, ec.unmarshalInputUpdateOhAuthTooTokenInput, ec.unmarshalInputUpdateOrgMembershipInput, + ec.unmarshalInputUpdateOrgSubscriptionInput, ec.unmarshalInputUpdateOrganizationInput, ec.unmarshalInputUpdateOrganizationSettingInput, ec.unmarshalInputUpdatePersonalAccessTokenInput, @@ -25089,6 +25698,15 @@ type ActionPlanBulkCreatePayload { query: String! ): OhAuthTooTokenSearchResult """ + Search across OrgSubscription objects + """ + adminOrgSubscriptionSearch( + """ + Search query + """ + query: String! + ): OrgSubscriptionSearchResult + """ Search across Organization objects """ adminOrganizationSearch( @@ -30284,6 +30902,49 @@ input CreateOrgMembershipInput { eventIDs: [ID!] } """ +CreateOrgSubscriptionInput is used for create OrgSubscription object. +Input was generated by ent. +""" +input CreateOrgSubscriptionInput { + """ + tags associated with the object + """ + tags: [String!] + """ + the stripe subscription id + """ + stripeSubscriptionID: String + """ + the common name of the product tier the subscription is associated with, e.g. starter tier + """ + productTier: String + """ + the product id that represents the tier in stripe + """ + stripeProductTierID: String + """ + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + """ + stripeSubscriptionStatus: String + """ + indicates if the subscription is active + """ + active: Boolean + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + """ + the features associated with the subscription + """ + features: [String!] + ownerID: ID +} +""" CreateOrganizationInput is used for create Organization object. Input was generated by ent. """ @@ -30332,6 +30993,7 @@ input CreateOrganizationInput { settingID: ID documentdatumIDs: [ID!] entitlementIDs: [ID!] + orgsubscriptionIDs: [ID!] organizationEntitlementIDs: [ID!] personalAccessTokenIDs: [ID!] apiTokenIDs: [ID!] @@ -43166,6 +43828,699 @@ input OrgMembershipWhereInput { roleIn: [OrgMembershipRole!] roleNotIn: [OrgMembershipRole!] } +type OrgSubscription implements Node { + id: ID! + createdAt: Time + updatedAt: Time + createdBy: String + updatedBy: String + """ + tags associated with the object + """ + tags: [String!] + deletedAt: Time + deletedBy: String + """ + the organization id that owns the object + """ + ownerID: ID + """ + the stripe subscription id + """ + stripeSubscriptionID: String + """ + the common name of the product tier the subscription is associated with, e.g. starter tier + """ + productTier: String + """ + the product id that represents the tier in stripe + """ + stripeProductTierID: String + """ + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + """ + stripeSubscriptionStatus: String + """ + indicates if the subscription is active + """ + active: Boolean! + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + """ + the features associated with the subscription + """ + features: [String!] + owner: Organization +} +""" +A connection to a list of items. +""" +type OrgSubscriptionConnection { + """ + A list of edges. + """ + edges: [OrgSubscriptionEdge] + """ + Information to aid in pagination. + """ + pageInfo: PageInfo! + """ + Identifies the total count of items in the connection. + """ + totalCount: Int! +} +""" +An edge in a connection. +""" +type OrgSubscriptionEdge { + """ + The item at the end of the edge. + """ + node: OrgSubscription + """ + A cursor for use in pagination. + """ + cursor: Cursor! +} +type OrgSubscriptionHistory implements Node { + id: ID! + historyTime: Time! + ref: String + operation: OrgSubscriptionHistoryOpType! + createdAt: Time + updatedAt: Time + createdBy: String + updatedBy: String + """ + tags associated with the object + """ + tags: [String!] + deletedAt: Time + deletedBy: String + """ + the organization id that owns the object + """ + ownerID: String + """ + the stripe subscription id + """ + stripeSubscriptionID: String + """ + the common name of the product tier the subscription is associated with, e.g. starter tier + """ + productTier: String + """ + the product id that represents the tier in stripe + """ + stripeProductTierID: String + """ + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + """ + stripeSubscriptionStatus: String + """ + indicates if the subscription is active + """ + active: Boolean! + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + """ + the features associated with the subscription + """ + features: [String!] +} +""" +A connection to a list of items. +""" +type OrgSubscriptionHistoryConnection { + """ + A list of edges. + """ + edges: [OrgSubscriptionHistoryEdge] + """ + Information to aid in pagination. + """ + pageInfo: PageInfo! + """ + Identifies the total count of items in the connection. + """ + totalCount: Int! +} +""" +An edge in a connection. +""" +type OrgSubscriptionHistoryEdge { + """ + The item at the end of the edge. + """ + node: OrgSubscriptionHistory + """ + A cursor for use in pagination. + """ + cursor: Cursor! +} +""" +OrgSubscriptionHistoryOpType is enum for the field operation +""" +enum OrgSubscriptionHistoryOpType @goModel(model: "github.com/theopenlane/entx/history.OpType") { + INSERT + UPDATE + DELETE +} +""" +OrgSubscriptionHistoryWhereInput is used for filtering OrgSubscriptionHistory objects. +Input was generated by ent. +""" +input OrgSubscriptionHistoryWhereInput { + not: OrgSubscriptionHistoryWhereInput + and: [OrgSubscriptionHistoryWhereInput!] + or: [OrgSubscriptionHistoryWhereInput!] + """ + id field predicates + """ + id: ID + idNEQ: ID + idIn: [ID!] + idNotIn: [ID!] + idGT: ID + idGTE: ID + idLT: ID + idLTE: ID + idEqualFold: ID + idContainsFold: ID + """ + history_time field predicates + """ + historyTime: Time + historyTimeNEQ: Time + historyTimeIn: [Time!] + historyTimeNotIn: [Time!] + historyTimeGT: Time + historyTimeGTE: Time + historyTimeLT: Time + historyTimeLTE: Time + """ + ref field predicates + """ + ref: String + refNEQ: String + refIn: [String!] + refNotIn: [String!] + refGT: String + refGTE: String + refLT: String + refLTE: String + refContains: String + refHasPrefix: String + refHasSuffix: String + refIsNil: Boolean + refNotNil: Boolean + refEqualFold: String + refContainsFold: String + """ + operation field predicates + """ + operation: OrgSubscriptionHistoryOpType + operationNEQ: OrgSubscriptionHistoryOpType + operationIn: [OrgSubscriptionHistoryOpType!] + operationNotIn: [OrgSubscriptionHistoryOpType!] + """ + created_at field predicates + """ + createdAt: Time + createdAtNEQ: Time + createdAtIn: [Time!] + createdAtNotIn: [Time!] + createdAtGT: Time + createdAtGTE: Time + createdAtLT: Time + createdAtLTE: Time + createdAtIsNil: Boolean + createdAtNotNil: Boolean + """ + updated_at field predicates + """ + updatedAt: Time + updatedAtNEQ: Time + updatedAtIn: [Time!] + updatedAtNotIn: [Time!] + updatedAtGT: Time + updatedAtGTE: Time + updatedAtLT: Time + updatedAtLTE: Time + updatedAtIsNil: Boolean + updatedAtNotNil: Boolean + """ + created_by field predicates + """ + createdBy: String + createdByNEQ: String + createdByIn: [String!] + createdByNotIn: [String!] + createdByGT: String + createdByGTE: String + createdByLT: String + createdByLTE: String + createdByContains: String + createdByHasPrefix: String + createdByHasSuffix: String + createdByIsNil: Boolean + createdByNotNil: Boolean + createdByEqualFold: String + createdByContainsFold: String + """ + updated_by field predicates + """ + updatedBy: String + updatedByNEQ: String + updatedByIn: [String!] + updatedByNotIn: [String!] + updatedByGT: String + updatedByGTE: String + updatedByLT: String + updatedByLTE: String + updatedByContains: String + updatedByHasPrefix: String + updatedByHasSuffix: String + updatedByIsNil: Boolean + updatedByNotNil: Boolean + updatedByEqualFold: String + updatedByContainsFold: String + """ + deleted_at field predicates + """ + deletedAt: Time + deletedAtNEQ: Time + deletedAtIn: [Time!] + deletedAtNotIn: [Time!] + deletedAtGT: Time + deletedAtGTE: Time + deletedAtLT: Time + deletedAtLTE: Time + deletedAtIsNil: Boolean + deletedAtNotNil: Boolean + """ + deleted_by field predicates + """ + deletedBy: String + deletedByNEQ: String + deletedByIn: [String!] + deletedByNotIn: [String!] + deletedByGT: String + deletedByGTE: String + deletedByLT: String + deletedByLTE: String + deletedByContains: String + deletedByHasPrefix: String + deletedByHasSuffix: String + deletedByIsNil: Boolean + deletedByNotNil: Boolean + deletedByEqualFold: String + deletedByContainsFold: String + """ + owner_id field predicates + """ + ownerID: String + ownerIDNEQ: String + ownerIDIn: [String!] + ownerIDNotIn: [String!] + ownerIDGT: String + ownerIDGTE: String + ownerIDLT: String + ownerIDLTE: String + ownerIDContains: String + ownerIDHasPrefix: String + ownerIDHasSuffix: String + ownerIDIsNil: Boolean + ownerIDNotNil: Boolean + ownerIDEqualFold: String + ownerIDContainsFold: String + """ + stripe_subscription_id field predicates + """ + stripeSubscriptionID: String + stripeSubscriptionIDNEQ: String + stripeSubscriptionIDIn: [String!] + stripeSubscriptionIDNotIn: [String!] + stripeSubscriptionIDGT: String + stripeSubscriptionIDGTE: String + stripeSubscriptionIDLT: String + stripeSubscriptionIDLTE: String + stripeSubscriptionIDContains: String + stripeSubscriptionIDHasPrefix: String + stripeSubscriptionIDHasSuffix: String + stripeSubscriptionIDIsNil: Boolean + stripeSubscriptionIDNotNil: Boolean + stripeSubscriptionIDEqualFold: String + stripeSubscriptionIDContainsFold: String + """ + product_tier field predicates + """ + productTier: String + productTierNEQ: String + productTierIn: [String!] + productTierNotIn: [String!] + productTierGT: String + productTierGTE: String + productTierLT: String + productTierLTE: String + productTierContains: String + productTierHasPrefix: String + productTierHasSuffix: String + productTierIsNil: Boolean + productTierNotNil: Boolean + productTierEqualFold: String + productTierContainsFold: String + """ + stripe_product_tier_id field predicates + """ + stripeProductTierID: String + stripeProductTierIDNEQ: String + stripeProductTierIDIn: [String!] + stripeProductTierIDNotIn: [String!] + stripeProductTierIDGT: String + stripeProductTierIDGTE: String + stripeProductTierIDLT: String + stripeProductTierIDLTE: String + stripeProductTierIDContains: String + stripeProductTierIDHasPrefix: String + stripeProductTierIDHasSuffix: String + stripeProductTierIDIsNil: Boolean + stripeProductTierIDNotNil: Boolean + stripeProductTierIDEqualFold: String + stripeProductTierIDContainsFold: String + """ + stripe_subscription_status field predicates + """ + stripeSubscriptionStatus: String + stripeSubscriptionStatusNEQ: String + stripeSubscriptionStatusIn: [String!] + stripeSubscriptionStatusNotIn: [String!] + stripeSubscriptionStatusGT: String + stripeSubscriptionStatusGTE: String + stripeSubscriptionStatusLT: String + stripeSubscriptionStatusLTE: String + stripeSubscriptionStatusContains: String + stripeSubscriptionStatusHasPrefix: String + stripeSubscriptionStatusHasSuffix: String + stripeSubscriptionStatusIsNil: Boolean + stripeSubscriptionStatusNotNil: Boolean + stripeSubscriptionStatusEqualFold: String + stripeSubscriptionStatusContainsFold: String + """ + active field predicates + """ + active: Boolean + activeNEQ: Boolean + """ + stripe_customer_id field predicates + """ + stripeCustomerID: String + stripeCustomerIDNEQ: String + stripeCustomerIDIn: [String!] + stripeCustomerIDNotIn: [String!] + stripeCustomerIDGT: String + stripeCustomerIDGTE: String + stripeCustomerIDLT: String + stripeCustomerIDLTE: String + stripeCustomerIDContains: String + stripeCustomerIDHasPrefix: String + stripeCustomerIDHasSuffix: String + stripeCustomerIDIsNil: Boolean + stripeCustomerIDNotNil: Boolean + stripeCustomerIDEqualFold: String + stripeCustomerIDContainsFold: String + """ + expires_at field predicates + """ + expiresAt: Time + expiresAtNEQ: Time + expiresAtIn: [Time!] + expiresAtNotIn: [Time!] + expiresAtGT: Time + expiresAtGTE: Time + expiresAtLT: Time + expiresAtLTE: Time + expiresAtIsNil: Boolean + expiresAtNotNil: Boolean +} +""" +OrgSubscriptionWhereInput is used for filtering OrgSubscription objects. +Input was generated by ent. +""" +input OrgSubscriptionWhereInput { + not: OrgSubscriptionWhereInput + and: [OrgSubscriptionWhereInput!] + or: [OrgSubscriptionWhereInput!] + """ + id field predicates + """ + id: ID + idNEQ: ID + idIn: [ID!] + idNotIn: [ID!] + idGT: ID + idGTE: ID + idLT: ID + idLTE: ID + idEqualFold: ID + idContainsFold: ID + """ + created_at field predicates + """ + createdAt: Time + createdAtNEQ: Time + createdAtIn: [Time!] + createdAtNotIn: [Time!] + createdAtGT: Time + createdAtGTE: Time + createdAtLT: Time + createdAtLTE: Time + createdAtIsNil: Boolean + createdAtNotNil: Boolean + """ + updated_at field predicates + """ + updatedAt: Time + updatedAtNEQ: Time + updatedAtIn: [Time!] + updatedAtNotIn: [Time!] + updatedAtGT: Time + updatedAtGTE: Time + updatedAtLT: Time + updatedAtLTE: Time + updatedAtIsNil: Boolean + updatedAtNotNil: Boolean + """ + created_by field predicates + """ + createdBy: String + createdByNEQ: String + createdByIn: [String!] + createdByNotIn: [String!] + createdByGT: String + createdByGTE: String + createdByLT: String + createdByLTE: String + createdByContains: String + createdByHasPrefix: String + createdByHasSuffix: String + createdByIsNil: Boolean + createdByNotNil: Boolean + createdByEqualFold: String + createdByContainsFold: String + """ + updated_by field predicates + """ + updatedBy: String + updatedByNEQ: String + updatedByIn: [String!] + updatedByNotIn: [String!] + updatedByGT: String + updatedByGTE: String + updatedByLT: String + updatedByLTE: String + updatedByContains: String + updatedByHasPrefix: String + updatedByHasSuffix: String + updatedByIsNil: Boolean + updatedByNotNil: Boolean + updatedByEqualFold: String + updatedByContainsFold: String + """ + deleted_at field predicates + """ + deletedAt: Time + deletedAtNEQ: Time + deletedAtIn: [Time!] + deletedAtNotIn: [Time!] + deletedAtGT: Time + deletedAtGTE: Time + deletedAtLT: Time + deletedAtLTE: Time + deletedAtIsNil: Boolean + deletedAtNotNil: Boolean + """ + deleted_by field predicates + """ + deletedBy: String + deletedByNEQ: String + deletedByIn: [String!] + deletedByNotIn: [String!] + deletedByGT: String + deletedByGTE: String + deletedByLT: String + deletedByLTE: String + deletedByContains: String + deletedByHasPrefix: String + deletedByHasSuffix: String + deletedByIsNil: Boolean + deletedByNotNil: Boolean + deletedByEqualFold: String + deletedByContainsFold: String + """ + owner_id field predicates + """ + ownerID: ID + ownerIDNEQ: ID + ownerIDIn: [ID!] + ownerIDNotIn: [ID!] + ownerIDGT: ID + ownerIDGTE: ID + ownerIDLT: ID + ownerIDLTE: ID + ownerIDContains: ID + ownerIDHasPrefix: ID + ownerIDHasSuffix: ID + ownerIDIsNil: Boolean + ownerIDNotNil: Boolean + ownerIDEqualFold: ID + ownerIDContainsFold: ID + """ + stripe_subscription_id field predicates + """ + stripeSubscriptionID: String + stripeSubscriptionIDNEQ: String + stripeSubscriptionIDIn: [String!] + stripeSubscriptionIDNotIn: [String!] + stripeSubscriptionIDGT: String + stripeSubscriptionIDGTE: String + stripeSubscriptionIDLT: String + stripeSubscriptionIDLTE: String + stripeSubscriptionIDContains: String + stripeSubscriptionIDHasPrefix: String + stripeSubscriptionIDHasSuffix: String + stripeSubscriptionIDIsNil: Boolean + stripeSubscriptionIDNotNil: Boolean + stripeSubscriptionIDEqualFold: String + stripeSubscriptionIDContainsFold: String + """ + product_tier field predicates + """ + productTier: String + productTierNEQ: String + productTierIn: [String!] + productTierNotIn: [String!] + productTierGT: String + productTierGTE: String + productTierLT: String + productTierLTE: String + productTierContains: String + productTierHasPrefix: String + productTierHasSuffix: String + productTierIsNil: Boolean + productTierNotNil: Boolean + productTierEqualFold: String + productTierContainsFold: String + """ + stripe_product_tier_id field predicates + """ + stripeProductTierID: String + stripeProductTierIDNEQ: String + stripeProductTierIDIn: [String!] + stripeProductTierIDNotIn: [String!] + stripeProductTierIDGT: String + stripeProductTierIDGTE: String + stripeProductTierIDLT: String + stripeProductTierIDLTE: String + stripeProductTierIDContains: String + stripeProductTierIDHasPrefix: String + stripeProductTierIDHasSuffix: String + stripeProductTierIDIsNil: Boolean + stripeProductTierIDNotNil: Boolean + stripeProductTierIDEqualFold: String + stripeProductTierIDContainsFold: String + """ + stripe_subscription_status field predicates + """ + stripeSubscriptionStatus: String + stripeSubscriptionStatusNEQ: String + stripeSubscriptionStatusIn: [String!] + stripeSubscriptionStatusNotIn: [String!] + stripeSubscriptionStatusGT: String + stripeSubscriptionStatusGTE: String + stripeSubscriptionStatusLT: String + stripeSubscriptionStatusLTE: String + stripeSubscriptionStatusContains: String + stripeSubscriptionStatusHasPrefix: String + stripeSubscriptionStatusHasSuffix: String + stripeSubscriptionStatusIsNil: Boolean + stripeSubscriptionStatusNotNil: Boolean + stripeSubscriptionStatusEqualFold: String + stripeSubscriptionStatusContainsFold: String + """ + active field predicates + """ + active: Boolean + activeNEQ: Boolean + """ + stripe_customer_id field predicates + """ + stripeCustomerID: String + stripeCustomerIDNEQ: String + stripeCustomerIDIn: [String!] + stripeCustomerIDNotIn: [String!] + stripeCustomerIDGT: String + stripeCustomerIDGTE: String + stripeCustomerIDLT: String + stripeCustomerIDLTE: String + stripeCustomerIDContains: String + stripeCustomerIDHasPrefix: String + stripeCustomerIDHasSuffix: String + stripeCustomerIDIsNil: Boolean + stripeCustomerIDNotNil: Boolean + stripeCustomerIDEqualFold: String + stripeCustomerIDContainsFold: String + """ + expires_at field predicates + """ + expiresAt: Time + expiresAtNEQ: Time + expiresAtIn: [Time!] + expiresAtNotIn: [Time!] + expiresAtGT: Time + expiresAtGTE: Time + expiresAtLT: Time + expiresAtLTE: Time + expiresAtIsNil: Boolean + expiresAtNotNil: Boolean + """ + owner edge predicates + """ + hasOwner: Boolean + hasOwnerWith: [OrganizationWhereInput!] +} type Organization implements Node { id: ID! createdAt: Time @@ -43276,6 +44631,7 @@ type Organization implements Node { setting: OrganizationSetting documentdata: [DocumentData!] entitlements: [Entitlement!] + orgsubscriptions: [OrgSubscription!] organizationEntitlement: [Entitlement!] personalAccessTokens: [PersonalAccessToken!] apiTokens: [APIToken!] @@ -44655,6 +46011,11 @@ input OrganizationWhereInput { hasEntitlements: Boolean hasEntitlementsWith: [EntitlementWhereInput!] """ + orgsubscriptions edge predicates + """ + hasOrgsubscriptions: Boolean + hasOrgsubscriptionsWith: [OrgSubscriptionWhereInput!] + """ organization_entitlement edge predicates """ hasOrganizationEntitlement: Boolean @@ -48417,6 +49778,58 @@ type Query { """ where: OrgMembershipHistoryWhereInput ): OrgMembershipHistoryConnection! + orgSubscriptions( + """ + Returns the elements in the list that come after the specified cursor. + """ + after: Cursor + + """ + Returns the first _n_ elements from the list. + """ + first: Int + + """ + Returns the elements in the list that come before the specified cursor. + """ + before: Cursor + + """ + Returns the last _n_ elements from the list. + """ + last: Int + + """ + Filtering options for OrgSubscriptions returned from the connection. + """ + where: OrgSubscriptionWhereInput + ): OrgSubscriptionConnection! + orgSubscriptionHistories( + """ + Returns the elements in the list that come after the specified cursor. + """ + after: Cursor + + """ + Returns the first _n_ elements from the list. + """ + first: Int + + """ + Returns the elements in the list that come before the specified cursor. + """ + before: Cursor + + """ + Returns the last _n_ elements from the list. + """ + last: Int + + """ + Filtering options for OrgSubscriptionHistories returned from the connection. + """ + where: OrgSubscriptionHistoryWhereInput + ): OrgSubscriptionHistoryConnection! organizations( """ Returns the elements in the list that come after the specified cursor. @@ -54964,6 +56377,60 @@ input UpdateOrgMembershipInput { clearEvents: Boolean } """ +UpdateOrgSubscriptionInput is used for update OrgSubscription object. +Input was generated by ent. +""" +input UpdateOrgSubscriptionInput { + """ + tags associated with the object + """ + tags: [String!] + appendTags: [String!] + clearTags: Boolean + """ + the stripe subscription id + """ + stripeSubscriptionID: String + clearStripeSubscriptionID: Boolean + """ + the common name of the product tier the subscription is associated with, e.g. starter tier + """ + productTier: String + clearProductTier: Boolean + """ + the product id that represents the tier in stripe + """ + stripeProductTierID: String + clearStripeProductTierID: Boolean + """ + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + """ + stripeSubscriptionStatus: String + clearStripeSubscriptionStatus: Boolean + """ + indicates if the subscription is active + """ + active: Boolean + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + clearStripeCustomerID: Boolean + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + clearExpiresAt: Boolean + """ + the features associated with the subscription + """ + features: [String!] + appendFeatures: [String!] + clearFeatures: Boolean + ownerID: ID + clearOwner: Boolean +} +""" UpdateOrganizationInput is used for update Organization object. Input was generated by ent. """ @@ -55036,6 +56503,9 @@ input UpdateOrganizationInput { addEntitlementIDs: [ID!] removeEntitlementIDs: [ID!] clearEntitlements: Boolean + addOrgsubscriptionIDs: [ID!] + removeOrgsubscriptionIDs: [ID!] + clearOrgsubscriptions: Boolean addOrganizationEntitlementIDs: [ID!] removeOrganizationEntitlementIDs: [ID!] clearOrganizationEntitlement: Boolean @@ -60430,6 +61900,109 @@ type OrgMembershipBulkCreatePayload { Created orgMemberships """ orgMemberships: [OrgMembership!] +}`, BuiltIn: false}, + {Name: "../../schema/orgsubscription.graphql", Input: `extend type Query { + """ + Look up orgSubscription by ID + """ + orgSubscription( + """ + ID of the orgSubscription + """ + id: ID! + ): OrgSubscription! +} + +extend type Mutation{ + """ + Create a new orgSubscription + """ + createOrgSubscription( + """ + values of the orgSubscription + """ + input: CreateOrgSubscriptionInput! + ): OrgSubscriptionCreatePayload! + """ + Create multiple new orgSubscriptions + """ + createBulkOrgSubscription( + """ + values of the orgSubscription + """ + input: [CreateOrgSubscriptionInput!] + ): OrgSubscriptionBulkCreatePayload! + """ + Create multiple new orgSubscriptions via file upload + """ + createBulkCSVOrgSubscription( + """ + csv file containing values of the orgSubscription + """ + input: Upload! + ): OrgSubscriptionBulkCreatePayload! + """ + Update an existing orgSubscription + """ + updateOrgSubscription( + """ + ID of the orgSubscription + """ + id: ID! + """ + New values for the orgSubscription + """ + input: UpdateOrgSubscriptionInput! + ): OrgSubscriptionUpdatePayload! + """ + Delete an existing orgSubscription + """ + deleteOrgSubscription( + """ + ID of the orgSubscription + """ + id: ID! + ): OrgSubscriptionDeletePayload! +} + +""" +Return response for createOrgSubscription mutation +""" +type OrgSubscriptionCreatePayload { + """ + Created orgSubscription + """ + orgSubscription: OrgSubscription! +} + +""" +Return response for updateOrgSubscription mutation +""" +type OrgSubscriptionUpdatePayload { + """ + Updated orgSubscription + """ + orgSubscription: OrgSubscription! +} + +""" +Return response for deleteOrgSubscription mutation +""" +type OrgSubscriptionDeletePayload { + """ + Deleted orgSubscription ID + """ + deletedID: ID! +} + +""" +Return response for createBulkOrgSubscription mutation +""" +type OrgSubscriptionBulkCreatePayload { + """ + Created orgSubscriptions + """ + orgSubscriptions: [OrgSubscription!] }`, BuiltIn: false}, {Name: "../../schema/personalaccesstoken.graphql", Input: `extend type Query { """ @@ -61201,6 +62774,15 @@ type RiskBulkCreatePayload { query: String! ): OhAuthTooTokenSearchResult """ + Search across OrgSubscription objects + """ + orgSubscriptionSearch( + """ + Search query + """ + query: String! + ): OrgSubscriptionSearchResult + """ Search across Organization objects """ organizationSearch( @@ -61358,6 +62940,7 @@ union SearchResult = | NarrativeSearchResult | OauthProviderSearchResult | OhAuthTooTokenSearchResult + | OrgSubscriptionSearchResult | OrganizationSearchResult | OrganizationSettingSearchResult | PersonalAccessTokenSearchResult @@ -61485,6 +63068,10 @@ type OhAuthTooTokenSearchResult { ohAuthTooTokens: [ OhAuthTooToken!] } +type OrgSubscriptionSearchResult { + orgSubscriptions: [ OrgSubscription!] +} + type OrganizationSearchResult { organizations: [ Organization!] } @@ -63302,6 +64889,38 @@ func (ec *executionContext) field_Mutation_createBulkCSVOrgMembership_argsInput( return zeroVal, nil } +func (ec *executionContext) field_Mutation_createBulkCSVOrgSubscription_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Mutation_createBulkCSVOrgSubscription_argsInput(ctx, rawArgs) + if err != nil { + return nil, err + } + args["input"] = arg0 + return args, nil +} +func (ec *executionContext) field_Mutation_createBulkCSVOrgSubscription_argsInput( + ctx context.Context, + rawArgs map[string]interface{}, +) (graphql.Upload, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["input"] + if !ok { + var zeroVal graphql.Upload + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) + if tmp, ok := rawArgs["input"]; ok { + return ec.unmarshalNUpload2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚐUpload(ctx, tmp) + } + + var zeroVal graphql.Upload + return zeroVal, nil +} + func (ec *executionContext) field_Mutation_createBulkCSVOrganizationSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} @@ -64454,6 +66073,38 @@ func (ec *executionContext) field_Mutation_createBulkOrgMembership_argsInput( return zeroVal, nil } +func (ec *executionContext) field_Mutation_createBulkOrgSubscription_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Mutation_createBulkOrgSubscription_argsInput(ctx, rawArgs) + if err != nil { + return nil, err + } + args["input"] = arg0 + return args, nil +} +func (ec *executionContext) field_Mutation_createBulkOrgSubscription_argsInput( + ctx context.Context, + rawArgs map[string]interface{}, +) ([]*generated.CreateOrgSubscriptionInput, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["input"] + if !ok { + var zeroVal []*generated.CreateOrgSubscriptionInput + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) + if tmp, ok := rawArgs["input"]; ok { + return ec.unmarshalOCreateOrgSubscriptionInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐCreateOrgSubscriptionInputᚄ(ctx, tmp) + } + + var zeroVal []*generated.CreateOrgSubscriptionInput + return zeroVal, nil +} + func (ec *executionContext) field_Mutation_createBulkOrganizationSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} @@ -65670,6 +67321,38 @@ func (ec *executionContext) field_Mutation_createOrgMembership_argsInput( return zeroVal, nil } +func (ec *executionContext) field_Mutation_createOrgSubscription_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Mutation_createOrgSubscription_argsInput(ctx, rawArgs) + if err != nil { + return nil, err + } + args["input"] = arg0 + return args, nil +} +func (ec *executionContext) field_Mutation_createOrgSubscription_argsInput( + ctx context.Context, + rawArgs map[string]interface{}, +) (generated.CreateOrgSubscriptionInput, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["input"] + if !ok { + var zeroVal generated.CreateOrgSubscriptionInput + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) + if tmp, ok := rawArgs["input"]; ok { + return ec.unmarshalNCreateOrgSubscriptionInput2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐCreateOrgSubscriptionInput(ctx, tmp) + } + + var zeroVal generated.CreateOrgSubscriptionInput + return zeroVal, nil +} + func (ec *executionContext) field_Mutation_createOrganizationSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} @@ -67041,6 +68724,38 @@ func (ec *executionContext) field_Mutation_deleteOrgMembership_argsID( return zeroVal, nil } +func (ec *executionContext) field_Mutation_deleteOrgSubscription_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Mutation_deleteOrgSubscription_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} +func (ec *executionContext) field_Mutation_deleteOrgSubscription_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + func (ec *executionContext) field_Mutation_deleteOrganizationSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} @@ -68932,22 +70647,81 @@ func (ec *executionContext) field_Mutation_updateOrgMembership_argsInput( return zeroVal, nil } -func (ec *executionContext) field_Mutation_updateOrganizationSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Mutation_updateOrgSubscription_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Mutation_updateOrganizationSetting_argsID(ctx, rawArgs) + arg0, err := ec.field_Mutation_updateOrgSubscription_argsID(ctx, rawArgs) if err != nil { return nil, err } args["id"] = arg0 - arg1, err := ec.field_Mutation_updateOrganizationSetting_argsInput(ctx, rawArgs) + arg1, err := ec.field_Mutation_updateOrgSubscription_argsInput(ctx, rawArgs) if err != nil { return nil, err } args["input"] = arg1 return args, nil } -func (ec *executionContext) field_Mutation_updateOrganizationSetting_argsID( +func (ec *executionContext) field_Mutation_updateOrgSubscription_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Mutation_updateOrgSubscription_argsInput( + ctx context.Context, + rawArgs map[string]interface{}, +) (generated.UpdateOrgSubscriptionInput, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["input"] + if !ok { + var zeroVal generated.UpdateOrgSubscriptionInput + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("input")) + if tmp, ok := rawArgs["input"]; ok { + return ec.unmarshalNUpdateOrgSubscriptionInput2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUpdateOrgSubscriptionInput(ctx, tmp) + } + + var zeroVal generated.UpdateOrgSubscriptionInput + return zeroVal, nil +} + +func (ec *executionContext) field_Mutation_updateOrganizationSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Mutation_updateOrganizationSetting_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + arg1, err := ec.field_Mutation_updateOrganizationSetting_argsInput(ctx, rawArgs) + if err != nil { + return nil, err + } + args["input"] = arg1 + return args, nil +} +func (ec *executionContext) field_Mutation_updateOrganizationSetting_argsID( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -71091,17 +72865,17 @@ func (ec *executionContext) field_Query_adminOhAuthTooTokenSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_adminOrganizationSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_adminOrgSubscriptionSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_adminOrganizationSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_adminOrgSubscriptionSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_adminOrganizationSearch_argsQuery( +func (ec *executionContext) field_Query_adminOrgSubscriptionSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -71123,209 +72897,17 @@ func (ec *executionContext) field_Query_adminOrganizationSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_adminOrganizationSettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_adminOrganizationSettingSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_adminOrganizationSettingSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_adminPersonalAccessTokenSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_adminPersonalAccessTokenSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_adminPersonalAccessTokenSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_adminProcedureSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_adminProcedureSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_adminProcedureSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_adminProgramSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_adminProgramSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_adminProgramSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_adminRiskSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_adminRiskSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_adminRiskSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_adminSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_adminSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_adminSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_adminStandardSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_adminOrganizationSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_adminStandardSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_adminOrganizationSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_adminStandardSearch_argsQuery( +func (ec *executionContext) field_Query_adminOrganizationSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -71347,17 +72929,17 @@ func (ec *executionContext) field_Query_adminStandardSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_adminSubcontrolSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_adminOrganizationSettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_adminSubcontrolSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_adminOrganizationSettingSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_adminSubcontrolSearch_argsQuery( +func (ec *executionContext) field_Query_adminOrganizationSettingSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -71379,17 +72961,17 @@ func (ec *executionContext) field_Query_adminSubcontrolSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_adminSubscriberSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_adminPersonalAccessTokenSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_adminSubscriberSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_adminPersonalAccessTokenSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_adminSubscriberSearch_argsQuery( +func (ec *executionContext) field_Query_adminPersonalAccessTokenSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -71411,17 +72993,241 @@ func (ec *executionContext) field_Query_adminSubscriberSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_adminTFASettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_adminProcedureSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_adminTFASettingSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_adminProcedureSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_adminTFASettingSearch_argsQuery( +func (ec *executionContext) field_Query_adminProcedureSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_adminProgramSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_adminProgramSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_adminProgramSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_adminRiskSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_adminRiskSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_adminRiskSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_adminSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_adminSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_adminSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_adminStandardSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_adminStandardSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_adminStandardSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_adminSubcontrolSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_adminSubcontrolSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_adminSubcontrolSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_adminSubscriberSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_adminSubscriberSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_adminSubscriberSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_adminTFASettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_adminTFASettingSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_adminTFASettingSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -80065,42 +81871,37 @@ func (ec *executionContext) field_Query_orgMemberships_argsWhere( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_orgSubscriptionHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_organizationHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_orgSubscriptionHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_organizationHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_orgSubscriptionHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_organizationHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_orgSubscriptionHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_organizationHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_orgSubscriptionHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_organizationHistories_argsOrderBy(ctx, rawArgs) + arg4, err := ec.field_Query_orgSubscriptionHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } - args["orderBy"] = arg4 - arg5, err := ec.field_Query_organizationHistories_argsWhere(ctx, rawArgs) - if err != nil { - return nil, err - } - args["where"] = arg5 + args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_organizationHistories_argsAfter( +func (ec *executionContext) field_Query_orgSubscriptionHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80122,7 +81923,7 @@ func (ec *executionContext) field_Query_organizationHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationHistories_argsFirst( +func (ec *executionContext) field_Query_orgSubscriptionHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80144,7 +81945,7 @@ func (ec *executionContext) field_Query_organizationHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationHistories_argsBefore( +func (ec *executionContext) field_Query_orgSubscriptionHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80166,7 +81967,7 @@ func (ec *executionContext) field_Query_organizationHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationHistories_argsLast( +func (ec *executionContext) field_Query_orgSubscriptionHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80188,61 +81989,39 @@ func (ec *executionContext) field_Query_organizationHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationHistories_argsOrderBy( +func (ec *executionContext) field_Query_orgSubscriptionHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.OrganizationHistoryOrder, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["orderBy"] - if !ok { - var zeroVal *generated.OrganizationHistoryOrder - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) - if tmp, ok := rawArgs["orderBy"]; ok { - return ec.unmarshalOOrganizationHistoryOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationHistoryOrder(ctx, tmp) - } - - var zeroVal *generated.OrganizationHistoryOrder - return zeroVal, nil -} - -func (ec *executionContext) field_Query_organizationHistories_argsWhere( - ctx context.Context, - rawArgs map[string]interface{}, -) (*generated.OrganizationHistoryWhereInput, error) { +) (*generated.OrgSubscriptionHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.OrganizationHistoryWhereInput + var zeroVal *generated.OrgSubscriptionHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOOrganizationHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationHistoryWhereInput(ctx, tmp) + return ec.unmarshalOOrgSubscriptionHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.OrganizationHistoryWhereInput + var zeroVal *generated.OrgSubscriptionHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_orgSubscriptionSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_organizationSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_orgSubscriptionSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_organizationSearch_argsQuery( +func (ec *executionContext) field_Query_orgSubscriptionSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -80264,37 +82043,69 @@ func (ec *executionContext) field_Query_organizationSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSettingHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_orgSubscription_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_organizationSettingHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_orgSubscription_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_orgSubscription_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_orgSubscriptions_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_orgSubscriptions_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_organizationSettingHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_orgSubscriptions_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_organizationSettingHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_orgSubscriptions_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_organizationSettingHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_orgSubscriptions_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_organizationSettingHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_orgSubscriptions_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_organizationSettingHistories_argsAfter( +func (ec *executionContext) field_Query_orgSubscriptions_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80316,7 +82127,7 @@ func (ec *executionContext) field_Query_organizationSettingHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSettingHistories_argsFirst( +func (ec *executionContext) field_Query_orgSubscriptions_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80338,7 +82149,7 @@ func (ec *executionContext) field_Query_organizationSettingHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSettingHistories_argsBefore( +func (ec *executionContext) field_Query_orgSubscriptions_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80360,7 +82171,7 @@ func (ec *executionContext) field_Query_organizationSettingHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSettingHistories_argsLast( +func (ec *executionContext) field_Query_orgSubscriptions_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80382,123 +82193,64 @@ func (ec *executionContext) field_Query_organizationSettingHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSettingHistories_argsWhere( +func (ec *executionContext) field_Query_orgSubscriptions_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.OrganizationSettingHistoryWhereInput, error) { +) (*generated.OrgSubscriptionWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.OrganizationSettingHistoryWhereInput + var zeroVal *generated.OrgSubscriptionWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOOrganizationSettingHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationSettingHistoryWhereInput(ctx, tmp) - } - - var zeroVal *generated.OrganizationSettingHistoryWhereInput - return zeroVal, nil -} - -func (ec *executionContext) field_Query_organizationSettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_organizationSettingSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_organizationSettingSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil + return ec.unmarshalOOrgSubscriptionWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionWhereInput(ctx, tmp) } - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string + var zeroVal *generated.OrgSubscriptionWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_organizationSetting_argsID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["id"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_organizationSetting_argsID( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["id"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - if tmp, ok := rawArgs["id"]; ok { - return ec.unmarshalNID2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_organizationSettings_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_organizationHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_organizationSettings_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_organizationHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_organizationSettings_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_organizationHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_organizationSettings_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_organizationHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_organizationSettings_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_organizationHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_organizationSettings_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_organizationHistories_argsOrderBy(ctx, rawArgs) if err != nil { return nil, err } - args["where"] = arg4 + args["orderBy"] = arg4 + arg5, err := ec.field_Query_organizationHistories_argsWhere(ctx, rawArgs) + if err != nil { + return nil, err + } + args["where"] = arg5 return args, nil } -func (ec *executionContext) field_Query_organizationSettings_argsAfter( +func (ec *executionContext) field_Query_organizationHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80520,7 +82272,7 @@ func (ec *executionContext) field_Query_organizationSettings_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSettings_argsFirst( +func (ec *executionContext) field_Query_organizationHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80542,7 +82294,7 @@ func (ec *executionContext) field_Query_organizationSettings_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSettings_argsBefore( +func (ec *executionContext) field_Query_organizationHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80564,7 +82316,7 @@ func (ec *executionContext) field_Query_organizationSettings_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSettings_argsLast( +func (ec *executionContext) field_Query_organizationHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80586,96 +82338,113 @@ func (ec *executionContext) field_Query_organizationSettings_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_organizationSettings_argsWhere( +func (ec *executionContext) field_Query_organizationHistories_argsOrderBy( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.OrganizationSettingWhereInput, error) { +) (*generated.OrganizationHistoryOrder, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["orderBy"] + if !ok { + var zeroVal *generated.OrganizationHistoryOrder + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) + if tmp, ok := rawArgs["orderBy"]; ok { + return ec.unmarshalOOrganizationHistoryOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationHistoryOrder(ctx, tmp) + } + + var zeroVal *generated.OrganizationHistoryOrder + return zeroVal, nil +} + +func (ec *executionContext) field_Query_organizationHistories_argsWhere( + ctx context.Context, + rawArgs map[string]interface{}, +) (*generated.OrganizationHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.OrganizationSettingWhereInput + var zeroVal *generated.OrganizationHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOOrganizationSettingWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationSettingWhereInput(ctx, tmp) + return ec.unmarshalOOrganizationHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.OrganizationSettingWhereInput + var zeroVal *generated.OrganizationHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_organization_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_organizationSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_organization_argsID(ctx, rawArgs) + arg0, err := ec.field_Query_organizationSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } - args["id"] = arg0 + args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_organization_argsID( +func (ec *executionContext) field_Query_organizationSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. - _, ok := rawArgs["id"] + _, ok := rawArgs["query"] if !ok { var zeroVal string return zeroVal, nil } - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - if tmp, ok := rawArgs["id"]; ok { - return ec.unmarshalNID2string(ctx, tmp) + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) } var zeroVal string return zeroVal, nil } -func (ec *executionContext) field_Query_organizations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_organizationSettingHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_organizations_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_organizationSettingHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_organizations_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_organizationSettingHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_organizations_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_organizationSettingHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_organizations_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_organizationSettingHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_organizations_argsOrderBy(ctx, rawArgs) - if err != nil { - return nil, err - } - args["orderBy"] = arg4 - arg5, err := ec.field_Query_organizations_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_organizationSettingHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } - args["where"] = arg5 + args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_organizations_argsAfter( +func (ec *executionContext) field_Query_organizationSettingHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80697,7 +82466,7 @@ func (ec *executionContext) field_Query_organizations_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_organizations_argsFirst( +func (ec *executionContext) field_Query_organizationSettingHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80719,7 +82488,7 @@ func (ec *executionContext) field_Query_organizations_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_organizations_argsBefore( +func (ec *executionContext) field_Query_organizationSettingHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80741,7 +82510,7 @@ func (ec *executionContext) field_Query_organizations_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_organizations_argsLast( +func (ec *executionContext) field_Query_organizationSettingHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80763,61 +82532,39 @@ func (ec *executionContext) field_Query_organizations_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_organizations_argsOrderBy( - ctx context.Context, - rawArgs map[string]interface{}, -) (*generated.OrganizationOrder, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["orderBy"] - if !ok { - var zeroVal *generated.OrganizationOrder - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) - if tmp, ok := rawArgs["orderBy"]; ok { - return ec.unmarshalOOrganizationOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationOrder(ctx, tmp) - } - - var zeroVal *generated.OrganizationOrder - return zeroVal, nil -} - -func (ec *executionContext) field_Query_organizations_argsWhere( +func (ec *executionContext) field_Query_organizationSettingHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.OrganizationWhereInput, error) { +) (*generated.OrganizationSettingHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.OrganizationWhereInput + var zeroVal *generated.OrganizationSettingHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOOrganizationWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInput(ctx, tmp) + return ec.unmarshalOOrganizationSettingHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationSettingHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.OrganizationWhereInput + var zeroVal *generated.OrganizationSettingHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_personalAccessTokenSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_organizationSettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_personalAccessTokenSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_organizationSettingSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_personalAccessTokenSearch_argsQuery( +func (ec *executionContext) field_Query_organizationSettingSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -80839,17 +82586,17 @@ func (ec *executionContext) field_Query_personalAccessTokenSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_personalAccessToken_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_organizationSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_personalAccessToken_argsID(ctx, rawArgs) + arg0, err := ec.field_Query_organizationSetting_argsID(ctx, rawArgs) if err != nil { return nil, err } args["id"] = arg0 return args, nil } -func (ec *executionContext) field_Query_personalAccessToken_argsID( +func (ec *executionContext) field_Query_organizationSetting_argsID( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -80871,37 +82618,37 @@ func (ec *executionContext) field_Query_personalAccessToken_argsID( return zeroVal, nil } -func (ec *executionContext) field_Query_personalAccessTokens_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_organizationSettings_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_personalAccessTokens_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_organizationSettings_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_personalAccessTokens_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_organizationSettings_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_personalAccessTokens_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_organizationSettings_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_personalAccessTokens_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_organizationSettings_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_personalAccessTokens_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_organizationSettings_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_personalAccessTokens_argsAfter( +func (ec *executionContext) field_Query_organizationSettings_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80923,7 +82670,7 @@ func (ec *executionContext) field_Query_personalAccessTokens_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_personalAccessTokens_argsFirst( +func (ec *executionContext) field_Query_organizationSettings_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80945,7 +82692,7 @@ func (ec *executionContext) field_Query_personalAccessTokens_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_personalAccessTokens_argsBefore( +func (ec *executionContext) field_Query_organizationSettings_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -80967,7 +82714,7 @@ func (ec *executionContext) field_Query_personalAccessTokens_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_personalAccessTokens_argsLast( +func (ec *executionContext) field_Query_organizationSettings_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -80989,59 +82736,96 @@ func (ec *executionContext) field_Query_personalAccessTokens_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_personalAccessTokens_argsWhere( +func (ec *executionContext) field_Query_organizationSettings_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.PersonalAccessTokenWhereInput, error) { +) (*generated.OrganizationSettingWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.PersonalAccessTokenWhereInput + var zeroVal *generated.OrganizationSettingWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOPersonalAccessTokenWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐPersonalAccessTokenWhereInput(ctx, tmp) + return ec.unmarshalOOrganizationSettingWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationSettingWhereInput(ctx, tmp) } - var zeroVal *generated.PersonalAccessTokenWhereInput + var zeroVal *generated.OrganizationSettingWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_procedureHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_organization_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_procedureHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_organization_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_organization_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_organizations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_organizations_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_procedureHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_organizations_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_procedureHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_organizations_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_procedureHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_organizations_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_procedureHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_organizations_argsOrderBy(ctx, rawArgs) if err != nil { return nil, err } - args["where"] = arg4 + args["orderBy"] = arg4 + arg5, err := ec.field_Query_organizations_argsWhere(ctx, rawArgs) + if err != nil { + return nil, err + } + args["where"] = arg5 return args, nil } -func (ec *executionContext) field_Query_procedureHistories_argsAfter( +func (ec *executionContext) field_Query_organizations_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81063,7 +82847,7 @@ func (ec *executionContext) field_Query_procedureHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_procedureHistories_argsFirst( +func (ec *executionContext) field_Query_organizations_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81085,7 +82869,7 @@ func (ec *executionContext) field_Query_procedureHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_procedureHistories_argsBefore( +func (ec *executionContext) field_Query_organizations_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81107,7 +82891,7 @@ func (ec *executionContext) field_Query_procedureHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_procedureHistories_argsLast( +func (ec *executionContext) field_Query_organizations_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81129,39 +82913,61 @@ func (ec *executionContext) field_Query_procedureHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_procedureHistories_argsWhere( +func (ec *executionContext) field_Query_organizations_argsOrderBy( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.ProcedureHistoryWhereInput, error) { +) (*generated.OrganizationOrder, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["orderBy"] + if !ok { + var zeroVal *generated.OrganizationOrder + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) + if tmp, ok := rawArgs["orderBy"]; ok { + return ec.unmarshalOOrganizationOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationOrder(ctx, tmp) + } + + var zeroVal *generated.OrganizationOrder + return zeroVal, nil +} + +func (ec *executionContext) field_Query_organizations_argsWhere( + ctx context.Context, + rawArgs map[string]interface{}, +) (*generated.OrganizationWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.ProcedureHistoryWhereInput + var zeroVal *generated.OrganizationWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOProcedureHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureHistoryWhereInput(ctx, tmp) + return ec.unmarshalOOrganizationWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInput(ctx, tmp) } - var zeroVal *generated.ProcedureHistoryWhereInput + var zeroVal *generated.OrganizationWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_procedureSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_personalAccessTokenSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_procedureSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_personalAccessTokenSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_procedureSearch_argsQuery( +func (ec *executionContext) field_Query_personalAccessTokenSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -81183,17 +82989,17 @@ func (ec *executionContext) field_Query_procedureSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_procedure_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_personalAccessToken_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_procedure_argsID(ctx, rawArgs) + arg0, err := ec.field_Query_personalAccessToken_argsID(ctx, rawArgs) if err != nil { return nil, err } args["id"] = arg0 return args, nil } -func (ec *executionContext) field_Query_procedure_argsID( +func (ec *executionContext) field_Query_personalAccessToken_argsID( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -81215,37 +83021,37 @@ func (ec *executionContext) field_Query_procedure_argsID( return zeroVal, nil } -func (ec *executionContext) field_Query_procedures_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_personalAccessTokens_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_procedures_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_personalAccessTokens_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_procedures_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_personalAccessTokens_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_procedures_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_personalAccessTokens_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_procedures_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_personalAccessTokens_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_procedures_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_personalAccessTokens_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_procedures_argsAfter( +func (ec *executionContext) field_Query_personalAccessTokens_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81267,7 +83073,7 @@ func (ec *executionContext) field_Query_procedures_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_procedures_argsFirst( +func (ec *executionContext) field_Query_personalAccessTokens_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81289,7 +83095,7 @@ func (ec *executionContext) field_Query_procedures_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_procedures_argsBefore( +func (ec *executionContext) field_Query_personalAccessTokens_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81311,7 +83117,7 @@ func (ec *executionContext) field_Query_procedures_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_procedures_argsLast( +func (ec *executionContext) field_Query_personalAccessTokens_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81333,59 +83139,59 @@ func (ec *executionContext) field_Query_procedures_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_procedures_argsWhere( +func (ec *executionContext) field_Query_personalAccessTokens_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.ProcedureWhereInput, error) { +) (*generated.PersonalAccessTokenWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.ProcedureWhereInput + var zeroVal *generated.PersonalAccessTokenWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOProcedureWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInput(ctx, tmp) + return ec.unmarshalOPersonalAccessTokenWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐPersonalAccessTokenWhereInput(ctx, tmp) } - var zeroVal *generated.ProcedureWhereInput + var zeroVal *generated.PersonalAccessTokenWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_programHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_procedureHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_programHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_procedureHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_programHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_procedureHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_programHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_procedureHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_programHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_procedureHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_programHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_procedureHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_programHistories_argsAfter( +func (ec *executionContext) field_Query_procedureHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81407,7 +83213,7 @@ func (ec *executionContext) field_Query_programHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_programHistories_argsFirst( +func (ec *executionContext) field_Query_procedureHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81429,7 +83235,7 @@ func (ec *executionContext) field_Query_programHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_programHistories_argsBefore( +func (ec *executionContext) field_Query_procedureHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81451,7 +83257,7 @@ func (ec *executionContext) field_Query_programHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_programHistories_argsLast( +func (ec *executionContext) field_Query_procedureHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81473,59 +83279,123 @@ func (ec *executionContext) field_Query_programHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_programHistories_argsWhere( +func (ec *executionContext) field_Query_procedureHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.ProgramHistoryWhereInput, error) { +) (*generated.ProcedureHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.ProgramHistoryWhereInput + var zeroVal *generated.ProcedureHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOProgramHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramHistoryWhereInput(ctx, tmp) + return ec.unmarshalOProcedureHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.ProgramHistoryWhereInput + var zeroVal *generated.ProcedureHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_programMembershipHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_procedureSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_programMembershipHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_procedureSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_procedureSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_procedure_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_procedure_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_procedure_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_procedures_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_procedures_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_programMembershipHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_procedures_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_programMembershipHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_procedures_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_programMembershipHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_procedures_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_programMembershipHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_procedures_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_programMembershipHistories_argsAfter( +func (ec *executionContext) field_Query_procedures_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81547,7 +83417,7 @@ func (ec *executionContext) field_Query_programMembershipHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_programMembershipHistories_argsFirst( +func (ec *executionContext) field_Query_procedures_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81569,7 +83439,7 @@ func (ec *executionContext) field_Query_programMembershipHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_programMembershipHistories_argsBefore( +func (ec *executionContext) field_Query_procedures_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81591,7 +83461,7 @@ func (ec *executionContext) field_Query_programMembershipHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_programMembershipHistories_argsLast( +func (ec *executionContext) field_Query_procedures_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81613,91 +83483,59 @@ func (ec *executionContext) field_Query_programMembershipHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_programMembershipHistories_argsWhere( +func (ec *executionContext) field_Query_procedures_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.ProgramMembershipHistoryWhereInput, error) { +) (*generated.ProcedureWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.ProgramMembershipHistoryWhereInput + var zeroVal *generated.ProcedureWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOProgramMembershipHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramMembershipHistoryWhereInput(ctx, tmp) - } - - var zeroVal *generated.ProgramMembershipHistoryWhereInput - return zeroVal, nil -} - -func (ec *executionContext) field_Query_programMembership_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_programMembership_argsID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["id"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_programMembership_argsID( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["id"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - if tmp, ok := rawArgs["id"]; ok { - return ec.unmarshalNID2string(ctx, tmp) + return ec.unmarshalOProcedureWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInput(ctx, tmp) } - var zeroVal string + var zeroVal *generated.ProcedureWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_programMemberships_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_programHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_programMemberships_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_programHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_programMemberships_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_programHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_programMemberships_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_programHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_programMemberships_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_programHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_programMemberships_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_programHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_programMemberships_argsAfter( +func (ec *executionContext) field_Query_programHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81719,7 +83557,7 @@ func (ec *executionContext) field_Query_programMemberships_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_programMemberships_argsFirst( +func (ec *executionContext) field_Query_programHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81741,7 +83579,7 @@ func (ec *executionContext) field_Query_programMemberships_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_programMemberships_argsBefore( +func (ec *executionContext) field_Query_programHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81763,7 +83601,7 @@ func (ec *executionContext) field_Query_programMemberships_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_programMemberships_argsLast( +func (ec *executionContext) field_Query_programHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81785,123 +83623,59 @@ func (ec *executionContext) field_Query_programMemberships_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_programMemberships_argsWhere( +func (ec *executionContext) field_Query_programHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.ProgramMembershipWhereInput, error) { +) (*generated.ProgramHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.ProgramMembershipWhereInput + var zeroVal *generated.ProgramHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOProgramMembershipWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramMembershipWhereInput(ctx, tmp) - } - - var zeroVal *generated.ProgramMembershipWhereInput - return zeroVal, nil -} - -func (ec *executionContext) field_Query_programSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_programSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_programSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_program_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_program_argsID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["id"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_program_argsID( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["id"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - if tmp, ok := rawArgs["id"]; ok { - return ec.unmarshalNID2string(ctx, tmp) + return ec.unmarshalOProgramHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramHistoryWhereInput(ctx, tmp) } - var zeroVal string + var zeroVal *generated.ProgramHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_programs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_programMembershipHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_programs_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_programMembershipHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_programs_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_programMembershipHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_programs_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_programMembershipHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_programs_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_programMembershipHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_programs_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_programMembershipHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_programs_argsAfter( +func (ec *executionContext) field_Query_programMembershipHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81923,7 +83697,7 @@ func (ec *executionContext) field_Query_programs_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_programs_argsFirst( +func (ec *executionContext) field_Query_programMembershipHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81945,7 +83719,7 @@ func (ec *executionContext) field_Query_programs_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_programs_argsBefore( +func (ec *executionContext) field_Query_programMembershipHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -81967,7 +83741,7 @@ func (ec *executionContext) field_Query_programs_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_programs_argsLast( +func (ec *executionContext) field_Query_programMembershipHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -81989,59 +83763,91 @@ func (ec *executionContext) field_Query_programs_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_programs_argsWhere( +func (ec *executionContext) field_Query_programMembershipHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.ProgramWhereInput, error) { +) (*generated.ProgramMembershipHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.ProgramWhereInput + var zeroVal *generated.ProgramMembershipHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOProgramWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInput(ctx, tmp) + return ec.unmarshalOProgramMembershipHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramMembershipHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.ProgramWhereInput + var zeroVal *generated.ProgramMembershipHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_riskHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_programMembership_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_riskHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_programMembership_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_programMembership_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_programMemberships_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_programMemberships_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_riskHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_programMemberships_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_riskHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_programMemberships_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_riskHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_programMemberships_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_riskHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_programMemberships_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_riskHistories_argsAfter( +func (ec *executionContext) field_Query_programMemberships_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82063,7 +83869,7 @@ func (ec *executionContext) field_Query_riskHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_riskHistories_argsFirst( +func (ec *executionContext) field_Query_programMemberships_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82085,7 +83891,7 @@ func (ec *executionContext) field_Query_riskHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_riskHistories_argsBefore( +func (ec *executionContext) field_Query_programMemberships_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82107,7 +83913,7 @@ func (ec *executionContext) field_Query_riskHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_riskHistories_argsLast( +func (ec *executionContext) field_Query_programMemberships_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82129,39 +83935,39 @@ func (ec *executionContext) field_Query_riskHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_riskHistories_argsWhere( +func (ec *executionContext) field_Query_programMemberships_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.RiskHistoryWhereInput, error) { +) (*generated.ProgramMembershipWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.RiskHistoryWhereInput + var zeroVal *generated.ProgramMembershipWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalORiskHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskHistoryWhereInput(ctx, tmp) + return ec.unmarshalOProgramMembershipWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramMembershipWhereInput(ctx, tmp) } - var zeroVal *generated.RiskHistoryWhereInput + var zeroVal *generated.ProgramMembershipWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_riskSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_programSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_riskSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_programSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_riskSearch_argsQuery( +func (ec *executionContext) field_Query_programSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -82183,17 +83989,17 @@ func (ec *executionContext) field_Query_riskSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_risk_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_program_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_risk_argsID(ctx, rawArgs) + arg0, err := ec.field_Query_program_argsID(ctx, rawArgs) if err != nil { return nil, err } args["id"] = arg0 return args, nil } -func (ec *executionContext) field_Query_risk_argsID( +func (ec *executionContext) field_Query_program_argsID( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -82215,37 +84021,37 @@ func (ec *executionContext) field_Query_risk_argsID( return zeroVal, nil } -func (ec *executionContext) field_Query_risks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_programs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_risks_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_programs_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_risks_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_programs_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_risks_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_programs_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_risks_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_programs_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_risks_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_programs_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_risks_argsAfter( +func (ec *executionContext) field_Query_programs_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82267,7 +84073,7 @@ func (ec *executionContext) field_Query_risks_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_risks_argsFirst( +func (ec *executionContext) field_Query_programs_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82289,7 +84095,7 @@ func (ec *executionContext) field_Query_risks_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_risks_argsBefore( +func (ec *executionContext) field_Query_programs_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82311,7 +84117,7 @@ func (ec *executionContext) field_Query_risks_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_risks_argsLast( +func (ec *executionContext) field_Query_programs_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82333,91 +84139,59 @@ func (ec *executionContext) field_Query_risks_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_risks_argsWhere( +func (ec *executionContext) field_Query_programs_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.RiskWhereInput, error) { +) (*generated.ProgramWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.RiskWhereInput + var zeroVal *generated.ProgramWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalORiskWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskWhereInput(ctx, tmp) - } - - var zeroVal *generated.RiskWhereInput - return zeroVal, nil -} - -func (ec *executionContext) field_Query_search_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_search_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_search_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) + return ec.unmarshalOProgramWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInput(ctx, tmp) } - var zeroVal string + var zeroVal *generated.ProgramWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_standardHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_riskHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_standardHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_riskHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_standardHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_riskHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_standardHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_riskHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_standardHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_riskHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_standardHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_riskHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_standardHistories_argsAfter( +func (ec *executionContext) field_Query_riskHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82439,7 +84213,7 @@ func (ec *executionContext) field_Query_standardHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_standardHistories_argsFirst( +func (ec *executionContext) field_Query_riskHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82461,7 +84235,7 @@ func (ec *executionContext) field_Query_standardHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_standardHistories_argsBefore( +func (ec *executionContext) field_Query_riskHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82483,7 +84257,7 @@ func (ec *executionContext) field_Query_standardHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_standardHistories_argsLast( +func (ec *executionContext) field_Query_riskHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82505,39 +84279,39 @@ func (ec *executionContext) field_Query_standardHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_standardHistories_argsWhere( +func (ec *executionContext) field_Query_riskHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.StandardHistoryWhereInput, error) { +) (*generated.RiskHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.StandardHistoryWhereInput + var zeroVal *generated.RiskHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOStandardHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐStandardHistoryWhereInput(ctx, tmp) + return ec.unmarshalORiskHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.StandardHistoryWhereInput + var zeroVal *generated.RiskHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_standardSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_riskSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_standardSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_riskSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_standardSearch_argsQuery( +func (ec *executionContext) field_Query_riskSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -82559,17 +84333,17 @@ func (ec *executionContext) field_Query_standardSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_standard_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_risk_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_standard_argsID(ctx, rawArgs) + arg0, err := ec.field_Query_risk_argsID(ctx, rawArgs) if err != nil { return nil, err } args["id"] = arg0 return args, nil } -func (ec *executionContext) field_Query_standard_argsID( +func (ec *executionContext) field_Query_risk_argsID( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -82591,37 +84365,37 @@ func (ec *executionContext) field_Query_standard_argsID( return zeroVal, nil } -func (ec *executionContext) field_Query_standards_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_risks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_standards_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_risks_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_standards_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_risks_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_standards_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_risks_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_standards_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_risks_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_standards_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_risks_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_standards_argsAfter( +func (ec *executionContext) field_Query_risks_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82643,7 +84417,7 @@ func (ec *executionContext) field_Query_standards_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_standards_argsFirst( +func (ec *executionContext) field_Query_risks_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82665,7 +84439,7 @@ func (ec *executionContext) field_Query_standards_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_standards_argsBefore( +func (ec *executionContext) field_Query_risks_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82687,7 +84461,7 @@ func (ec *executionContext) field_Query_standards_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_standards_argsLast( +func (ec *executionContext) field_Query_risks_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82709,59 +84483,91 @@ func (ec *executionContext) field_Query_standards_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_standards_argsWhere( +func (ec *executionContext) field_Query_risks_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.StandardWhereInput, error) { +) (*generated.RiskWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.StandardWhereInput + var zeroVal *generated.RiskWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOStandardWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐStandardWhereInput(ctx, tmp) + return ec.unmarshalORiskWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskWhereInput(ctx, tmp) } - var zeroVal *generated.StandardWhereInput + var zeroVal *generated.RiskWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrolHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_search_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_subcontrolHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_search_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_search_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_standardHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_standardHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_subcontrolHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_standardHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_subcontrolHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_standardHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_subcontrolHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_standardHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_subcontrolHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_standardHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_subcontrolHistories_argsAfter( +func (ec *executionContext) field_Query_standardHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82783,7 +84589,7 @@ func (ec *executionContext) field_Query_subcontrolHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrolHistories_argsFirst( +func (ec *executionContext) field_Query_standardHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82805,7 +84611,7 @@ func (ec *executionContext) field_Query_subcontrolHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrolHistories_argsBefore( +func (ec *executionContext) field_Query_standardHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82827,7 +84633,7 @@ func (ec *executionContext) field_Query_subcontrolHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrolHistories_argsLast( +func (ec *executionContext) field_Query_standardHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -82849,39 +84655,39 @@ func (ec *executionContext) field_Query_subcontrolHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrolHistories_argsWhere( +func (ec *executionContext) field_Query_standardHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.SubcontrolHistoryWhereInput, error) { +) (*generated.StandardHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.SubcontrolHistoryWhereInput + var zeroVal *generated.StandardHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOSubcontrolHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubcontrolHistoryWhereInput(ctx, tmp) + return ec.unmarshalOStandardHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐStandardHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.SubcontrolHistoryWhereInput + var zeroVal *generated.StandardHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrolSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_standardSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_subcontrolSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_standardSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_subcontrolSearch_argsQuery( +func (ec *executionContext) field_Query_standardSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -82903,17 +84709,17 @@ func (ec *executionContext) field_Query_subcontrolSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrol_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_standard_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_subcontrol_argsID(ctx, rawArgs) + arg0, err := ec.field_Query_standard_argsID(ctx, rawArgs) if err != nil { return nil, err } args["id"] = arg0 return args, nil } -func (ec *executionContext) field_Query_subcontrol_argsID( +func (ec *executionContext) field_Query_standard_argsID( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -82935,37 +84741,37 @@ func (ec *executionContext) field_Query_subcontrol_argsID( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrols_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_standards_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_subcontrols_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_standards_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_subcontrols_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_standards_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_subcontrols_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_standards_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_subcontrols_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_standards_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_subcontrols_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_standards_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_subcontrols_argsAfter( +func (ec *executionContext) field_Query_standards_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -82987,7 +84793,7 @@ func (ec *executionContext) field_Query_subcontrols_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrols_argsFirst( +func (ec *executionContext) field_Query_standards_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83009,7 +84815,7 @@ func (ec *executionContext) field_Query_subcontrols_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrols_argsBefore( +func (ec *executionContext) field_Query_standards_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83031,7 +84837,7 @@ func (ec *executionContext) field_Query_subcontrols_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrols_argsLast( +func (ec *executionContext) field_Query_standards_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83053,123 +84859,59 @@ func (ec *executionContext) field_Query_subcontrols_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_subcontrols_argsWhere( +func (ec *executionContext) field_Query_standards_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.SubcontrolWhereInput, error) { +) (*generated.StandardWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.SubcontrolWhereInput + var zeroVal *generated.StandardWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOSubcontrolWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubcontrolWhereInput(ctx, tmp) - } - - var zeroVal *generated.SubcontrolWhereInput - return zeroVal, nil -} - -func (ec *executionContext) field_Query_subscriberSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_subscriberSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_subscriberSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_subscriber_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_subscriber_argsEmail(ctx, rawArgs) - if err != nil { - return nil, err - } - args["email"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_subscriber_argsEmail( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["email"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("email")) - if tmp, ok := rawArgs["email"]; ok { - return ec.unmarshalNString2string(ctx, tmp) + return ec.unmarshalOStandardWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐStandardWhereInput(ctx, tmp) } - var zeroVal string + var zeroVal *generated.StandardWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_subscribers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_subcontrolHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_subscribers_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_subcontrolHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_subscribers_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_subcontrolHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_subscribers_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_subcontrolHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_subscribers_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_subcontrolHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_subscribers_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_subcontrolHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_subscribers_argsAfter( +func (ec *executionContext) field_Query_subcontrolHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83191,7 +84933,7 @@ func (ec *executionContext) field_Query_subscribers_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_subscribers_argsFirst( +func (ec *executionContext) field_Query_subcontrolHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83213,7 +84955,7 @@ func (ec *executionContext) field_Query_subscribers_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_subscribers_argsBefore( +func (ec *executionContext) field_Query_subcontrolHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83235,7 +84977,7 @@ func (ec *executionContext) field_Query_subscribers_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_subscribers_argsLast( +func (ec *executionContext) field_Query_subcontrolHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83257,39 +84999,39 @@ func (ec *executionContext) field_Query_subscribers_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_subscribers_argsWhere( +func (ec *executionContext) field_Query_subcontrolHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.SubscriberWhereInput, error) { +) (*generated.SubcontrolHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.SubscriberWhereInput + var zeroVal *generated.SubcontrolHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOSubscriberWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubscriberWhereInput(ctx, tmp) + return ec.unmarshalOSubcontrolHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubcontrolHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.SubscriberWhereInput + var zeroVal *generated.SubcontrolHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_tFASettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_subcontrolSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_tFASettingSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_subcontrolSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_tFASettingSearch_argsQuery( +func (ec *executionContext) field_Query_subcontrolSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -83311,37 +85053,69 @@ func (ec *executionContext) field_Query_tFASettingSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_taskHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_subcontrol_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_taskHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_subcontrol_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_subcontrol_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_subcontrols_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_subcontrols_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_taskHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_subcontrols_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_taskHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_subcontrols_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_taskHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_subcontrols_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_taskHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_subcontrols_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_taskHistories_argsAfter( +func (ec *executionContext) field_Query_subcontrols_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83363,7 +85137,7 @@ func (ec *executionContext) field_Query_taskHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_taskHistories_argsFirst( +func (ec *executionContext) field_Query_subcontrols_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83385,7 +85159,7 @@ func (ec *executionContext) field_Query_taskHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_taskHistories_argsBefore( +func (ec *executionContext) field_Query_subcontrols_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83407,7 +85181,7 @@ func (ec *executionContext) field_Query_taskHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_taskHistories_argsLast( +func (ec *executionContext) field_Query_subcontrols_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83429,39 +85203,39 @@ func (ec *executionContext) field_Query_taskHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_taskHistories_argsWhere( +func (ec *executionContext) field_Query_subcontrols_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.TaskHistoryWhereInput, error) { +) (*generated.SubcontrolWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.TaskHistoryWhereInput + var zeroVal *generated.SubcontrolWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOTaskHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskHistoryWhereInput(ctx, tmp) + return ec.unmarshalOSubcontrolWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubcontrolWhereInput(ctx, tmp) } - var zeroVal *generated.TaskHistoryWhereInput + var zeroVal *generated.SubcontrolWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_taskSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_subscriberSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_taskSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_subscriberSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_taskSearch_argsQuery( +func (ec *executionContext) field_Query_subscriberSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -83483,69 +85257,69 @@ func (ec *executionContext) field_Query_taskSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_task_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_subscriber_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_task_argsID(ctx, rawArgs) + arg0, err := ec.field_Query_subscriber_argsEmail(ctx, rawArgs) if err != nil { return nil, err } - args["id"] = arg0 + args["email"] = arg0 return args, nil } -func (ec *executionContext) field_Query_task_argsID( +func (ec *executionContext) field_Query_subscriber_argsEmail( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. - _, ok := rawArgs["id"] + _, ok := rawArgs["email"] if !ok { var zeroVal string return zeroVal, nil } - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - if tmp, ok := rawArgs["id"]; ok { - return ec.unmarshalNID2string(ctx, tmp) + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("email")) + if tmp, ok := rawArgs["email"]; ok { + return ec.unmarshalNString2string(ctx, tmp) } var zeroVal string return zeroVal, nil } -func (ec *executionContext) field_Query_tasks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_subscribers_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_tasks_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_subscribers_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_tasks_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_subscribers_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_tasks_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_subscribers_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_tasks_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_subscribers_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_tasks_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_subscribers_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_tasks_argsAfter( +func (ec *executionContext) field_Query_subscribers_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83567,7 +85341,7 @@ func (ec *executionContext) field_Query_tasks_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_tasks_argsFirst( +func (ec *executionContext) field_Query_subscribers_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83589,7 +85363,7 @@ func (ec *executionContext) field_Query_tasks_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_tasks_argsBefore( +func (ec *executionContext) field_Query_subscribers_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83611,7 +85385,7 @@ func (ec *executionContext) field_Query_tasks_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_tasks_argsLast( +func (ec *executionContext) field_Query_subscribers_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83633,64 +85407,91 @@ func (ec *executionContext) field_Query_tasks_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_tasks_argsWhere( +func (ec *executionContext) field_Query_subscribers_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.TaskWhereInput, error) { +) (*generated.SubscriberWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.TaskWhereInput + var zeroVal *generated.SubscriberWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOTaskWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskWhereInput(ctx, tmp) + return ec.unmarshalOSubscriberWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubscriberWhereInput(ctx, tmp) } - var zeroVal *generated.TaskWhereInput + var zeroVal *generated.SubscriberWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_templateHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_tFASettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_templateHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_tFASettingSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_tFASettingSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_taskHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_taskHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_templateHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_taskHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_templateHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_taskHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_templateHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_taskHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_templateHistories_argsOrderBy(ctx, rawArgs) - if err != nil { - return nil, err - } - args["orderBy"] = arg4 - arg5, err := ec.field_Query_templateHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_taskHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } - args["where"] = arg5 + args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_templateHistories_argsAfter( +func (ec *executionContext) field_Query_taskHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83712,7 +85513,7 @@ func (ec *executionContext) field_Query_templateHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_templateHistories_argsFirst( +func (ec *executionContext) field_Query_taskHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83734,7 +85535,7 @@ func (ec *executionContext) field_Query_templateHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_templateHistories_argsBefore( +func (ec *executionContext) field_Query_taskHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83756,7 +85557,7 @@ func (ec *executionContext) field_Query_templateHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_templateHistories_argsLast( +func (ec *executionContext) field_Query_taskHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83778,61 +85579,39 @@ func (ec *executionContext) field_Query_templateHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_templateHistories_argsOrderBy( - ctx context.Context, - rawArgs map[string]interface{}, -) (*generated.TemplateHistoryOrder, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["orderBy"] - if !ok { - var zeroVal *generated.TemplateHistoryOrder - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) - if tmp, ok := rawArgs["orderBy"]; ok { - return ec.unmarshalOTemplateHistoryOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateHistoryOrder(ctx, tmp) - } - - var zeroVal *generated.TemplateHistoryOrder - return zeroVal, nil -} - -func (ec *executionContext) field_Query_templateHistories_argsWhere( +func (ec *executionContext) field_Query_taskHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.TemplateHistoryWhereInput, error) { +) (*generated.TaskHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.TemplateHistoryWhereInput + var zeroVal *generated.TaskHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOTemplateHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateHistoryWhereInput(ctx, tmp) + return ec.unmarshalOTaskHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.TemplateHistoryWhereInput + var zeroVal *generated.TaskHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_templateSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_taskSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_templateSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_taskSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_templateSearch_argsQuery( +func (ec *executionContext) field_Query_taskSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -83854,17 +85633,17 @@ func (ec *executionContext) field_Query_templateSearch_argsQuery( return zeroVal, nil } -func (ec *executionContext) field_Query_template_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_task_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_template_argsID(ctx, rawArgs) + arg0, err := ec.field_Query_task_argsID(ctx, rawArgs) if err != nil { return nil, err } args["id"] = arg0 return args, nil } -func (ec *executionContext) field_Query_template_argsID( +func (ec *executionContext) field_Query_task_argsID( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { @@ -83886,42 +85665,37 @@ func (ec *executionContext) field_Query_template_argsID( return zeroVal, nil } -func (ec *executionContext) field_Query_templates_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_tasks_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_templates_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_tasks_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_templates_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_tasks_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_templates_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_tasks_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_templates_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_tasks_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_templates_argsOrderBy(ctx, rawArgs) - if err != nil { - return nil, err - } - args["orderBy"] = arg4 - arg5, err := ec.field_Query_templates_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_tasks_argsWhere(ctx, rawArgs) if err != nil { return nil, err } - args["where"] = arg5 + args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_templates_argsAfter( +func (ec *executionContext) field_Query_tasks_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83943,7 +85717,7 @@ func (ec *executionContext) field_Query_templates_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_templates_argsFirst( +func (ec *executionContext) field_Query_tasks_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -83965,7 +85739,7 @@ func (ec *executionContext) field_Query_templates_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_templates_argsBefore( +func (ec *executionContext) field_Query_tasks_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -83987,7 +85761,7 @@ func (ec *executionContext) field_Query_templates_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_templates_argsLast( +func (ec *executionContext) field_Query_tasks_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84009,113 +85783,64 @@ func (ec *executionContext) field_Query_templates_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_templates_argsOrderBy( - ctx context.Context, - rawArgs map[string]interface{}, -) (*generated.TemplateOrder, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["orderBy"] - if !ok { - var zeroVal *generated.TemplateOrder - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) - if tmp, ok := rawArgs["orderBy"]; ok { - return ec.unmarshalOTemplateOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateOrder(ctx, tmp) - } - - var zeroVal *generated.TemplateOrder - return zeroVal, nil -} - -func (ec *executionContext) field_Query_templates_argsWhere( +func (ec *executionContext) field_Query_tasks_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.TemplateWhereInput, error) { +) (*generated.TaskWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.TemplateWhereInput + var zeroVal *generated.TaskWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOTemplateWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateWhereInput(ctx, tmp) - } - - var zeroVal *generated.TemplateWhereInput - return zeroVal, nil -} - -func (ec *executionContext) field_Query_tfaSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_tfaSetting_argsID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["id"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_tfaSetting_argsID( - ctx context.Context, - rawArgs map[string]interface{}, -) (*string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["id"] - if !ok { - var zeroVal *string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - if tmp, ok := rawArgs["id"]; ok { - return ec.unmarshalOID2ᚖstring(ctx, tmp) + return ec.unmarshalOTaskWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskWhereInput(ctx, tmp) } - var zeroVal *string + var zeroVal *generated.TaskWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_tfaSettings_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_templateHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_tfaSettings_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_templateHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_tfaSettings_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_templateHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_tfaSettings_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_templateHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_tfaSettings_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_templateHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_tfaSettings_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_templateHistories_argsOrderBy(ctx, rawArgs) if err != nil { return nil, err } - args["where"] = arg4 + args["orderBy"] = arg4 + arg5, err := ec.field_Query_templateHistories_argsWhere(ctx, rawArgs) + if err != nil { + return nil, err + } + args["where"] = arg5 return args, nil } -func (ec *executionContext) field_Query_tfaSettings_argsAfter( +func (ec *executionContext) field_Query_templateHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84137,7 +85862,7 @@ func (ec *executionContext) field_Query_tfaSettings_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_tfaSettings_argsFirst( +func (ec *executionContext) field_Query_templateHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84159,7 +85884,7 @@ func (ec *executionContext) field_Query_tfaSettings_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_tfaSettings_argsBefore( +func (ec *executionContext) field_Query_templateHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84181,7 +85906,7 @@ func (ec *executionContext) field_Query_tfaSettings_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_tfaSettings_argsLast( +func (ec *executionContext) field_Query_templateHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84203,64 +85928,150 @@ func (ec *executionContext) field_Query_tfaSettings_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_tfaSettings_argsWhere( +func (ec *executionContext) field_Query_templateHistories_argsOrderBy( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.TFASettingWhereInput, error) { +) (*generated.TemplateHistoryOrder, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["orderBy"] + if !ok { + var zeroVal *generated.TemplateHistoryOrder + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) + if tmp, ok := rawArgs["orderBy"]; ok { + return ec.unmarshalOTemplateHistoryOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateHistoryOrder(ctx, tmp) + } + + var zeroVal *generated.TemplateHistoryOrder + return zeroVal, nil +} + +func (ec *executionContext) field_Query_templateHistories_argsWhere( + ctx context.Context, + rawArgs map[string]interface{}, +) (*generated.TemplateHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.TFASettingWhereInput + var zeroVal *generated.TemplateHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOTFASettingWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTFASettingWhereInput(ctx, tmp) + return ec.unmarshalOTemplateHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.TFASettingWhereInput + var zeroVal *generated.TemplateHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_userHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_templateSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_userHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_templateSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_templateSearch_argsQuery( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["query"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_template_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_template_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_template_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_templates_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_templates_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_userHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_templates_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_userHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_templates_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_userHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_templates_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_userHistories_argsOrderBy(ctx, rawArgs) + arg4, err := ec.field_Query_templates_argsOrderBy(ctx, rawArgs) if err != nil { return nil, err } args["orderBy"] = arg4 - arg5, err := ec.field_Query_userHistories_argsWhere(ctx, rawArgs) + arg5, err := ec.field_Query_templates_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg5 return args, nil } -func (ec *executionContext) field_Query_userHistories_argsAfter( +func (ec *executionContext) field_Query_templates_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84282,7 +86093,7 @@ func (ec *executionContext) field_Query_userHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_userHistories_argsFirst( +func (ec *executionContext) field_Query_templates_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84304,7 +86115,7 @@ func (ec *executionContext) field_Query_userHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_userHistories_argsBefore( +func (ec *executionContext) field_Query_templates_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84326,7 +86137,7 @@ func (ec *executionContext) field_Query_userHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_userHistories_argsLast( +func (ec *executionContext) field_Query_templates_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84348,113 +86159,113 @@ func (ec *executionContext) field_Query_userHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_userHistories_argsOrderBy( +func (ec *executionContext) field_Query_templates_argsOrderBy( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.UserHistoryOrder, error) { +) (*generated.TemplateOrder, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["orderBy"] if !ok { - var zeroVal *generated.UserHistoryOrder + var zeroVal *generated.TemplateOrder return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) if tmp, ok := rawArgs["orderBy"]; ok { - return ec.unmarshalOUserHistoryOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserHistoryOrder(ctx, tmp) + return ec.unmarshalOTemplateOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateOrder(ctx, tmp) } - var zeroVal *generated.UserHistoryOrder + var zeroVal *generated.TemplateOrder return zeroVal, nil } -func (ec *executionContext) field_Query_userHistories_argsWhere( +func (ec *executionContext) field_Query_templates_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.UserHistoryWhereInput, error) { +) (*generated.TemplateWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.UserHistoryWhereInput + var zeroVal *generated.TemplateWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOUserHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserHistoryWhereInput(ctx, tmp) + return ec.unmarshalOTemplateWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateWhereInput(ctx, tmp) } - var zeroVal *generated.UserHistoryWhereInput + var zeroVal *generated.TemplateWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_userSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_tfaSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_userSearch_argsQuery(ctx, rawArgs) + arg0, err := ec.field_Query_tfaSetting_argsID(ctx, rawArgs) if err != nil { return nil, err } - args["query"] = arg0 + args["id"] = arg0 return args, nil } -func (ec *executionContext) field_Query_userSearch_argsQuery( +func (ec *executionContext) field_Query_tfaSetting_argsID( ctx context.Context, rawArgs map[string]interface{}, -) (string, error) { +) (*string, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. - _, ok := rawArgs["query"] + _, ok := rawArgs["id"] if !ok { - var zeroVal string + var zeroVal *string return zeroVal, nil } - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalOID2ᚖstring(ctx, tmp) } - var zeroVal string + var zeroVal *string return zeroVal, nil } -func (ec *executionContext) field_Query_userSettingHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_tfaSettings_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_userSettingHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_tfaSettings_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_userSettingHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_tfaSettings_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_userSettingHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_tfaSettings_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_userSettingHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_tfaSettings_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_userSettingHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_tfaSettings_argsWhere(ctx, rawArgs) if err != nil { return nil, err } args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_userSettingHistories_argsAfter( +func (ec *executionContext) field_Query_tfaSettings_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84476,7 +86287,7 @@ func (ec *executionContext) field_Query_userSettingHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_userSettingHistories_argsFirst( +func (ec *executionContext) field_Query_tfaSettings_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84498,7 +86309,7 @@ func (ec *executionContext) field_Query_userSettingHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_userSettingHistories_argsBefore( +func (ec *executionContext) field_Query_tfaSettings_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84520,7 +86331,7 @@ func (ec *executionContext) field_Query_userSettingHistories_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_userSettingHistories_argsLast( +func (ec *executionContext) field_Query_tfaSettings_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84542,123 +86353,64 @@ func (ec *executionContext) field_Query_userSettingHistories_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_userSettingHistories_argsWhere( +func (ec *executionContext) field_Query_tfaSettings_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.UserSettingHistoryWhereInput, error) { +) (*generated.TFASettingWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.UserSettingHistoryWhereInput + var zeroVal *generated.TFASettingWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOUserSettingHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserSettingHistoryWhereInput(ctx, tmp) - } - - var zeroVal *generated.UserSettingHistoryWhereInput - return zeroVal, nil -} - -func (ec *executionContext) field_Query_userSettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_userSettingSearch_argsQuery(ctx, rawArgs) - if err != nil { - return nil, err - } - args["query"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_userSettingSearch_argsQuery( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["query"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) - if tmp, ok := rawArgs["query"]; ok { - return ec.unmarshalNString2string(ctx, tmp) - } - - var zeroVal string - return zeroVal, nil -} - -func (ec *executionContext) field_Query_userSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Query_userSetting_argsID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["id"] = arg0 - return args, nil -} -func (ec *executionContext) field_Query_userSetting_argsID( - ctx context.Context, - rawArgs map[string]interface{}, -) (string, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["id"] - if !ok { - var zeroVal string - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - if tmp, ok := rawArgs["id"]; ok { - return ec.unmarshalNID2string(ctx, tmp) + return ec.unmarshalOTFASettingWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTFASettingWhereInput(ctx, tmp) } - var zeroVal string + var zeroVal *generated.TFASettingWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_userSettings_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_userHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_userSettings_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_userHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_userSettings_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_userHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_userSettings_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_userHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_userSettings_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_userHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_userSettings_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_userHistories_argsOrderBy(ctx, rawArgs) if err != nil { return nil, err } - args["where"] = arg4 + args["orderBy"] = arg4 + arg5, err := ec.field_Query_userHistories_argsWhere(ctx, rawArgs) + if err != nil { + return nil, err + } + args["where"] = arg5 return args, nil } -func (ec *executionContext) field_Query_userSettings_argsAfter( +func (ec *executionContext) field_Query_userHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84680,7 +86432,7 @@ func (ec *executionContext) field_Query_userSettings_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_userSettings_argsFirst( +func (ec *executionContext) field_Query_userHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84702,7 +86454,7 @@ func (ec *executionContext) field_Query_userSettings_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_userSettings_argsBefore( +func (ec *executionContext) field_Query_userHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84724,7 +86476,7 @@ func (ec *executionContext) field_Query_userSettings_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_userSettings_argsLast( +func (ec *executionContext) field_Query_userHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84746,96 +86498,113 @@ func (ec *executionContext) field_Query_userSettings_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_userSettings_argsWhere( +func (ec *executionContext) field_Query_userHistories_argsOrderBy( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.UserSettingWhereInput, error) { +) (*generated.UserHistoryOrder, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["orderBy"] + if !ok { + var zeroVal *generated.UserHistoryOrder + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) + if tmp, ok := rawArgs["orderBy"]; ok { + return ec.unmarshalOUserHistoryOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserHistoryOrder(ctx, tmp) + } + + var zeroVal *generated.UserHistoryOrder + return zeroVal, nil +} + +func (ec *executionContext) field_Query_userHistories_argsWhere( + ctx context.Context, + rawArgs map[string]interface{}, +) (*generated.UserHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.UserSettingWhereInput + var zeroVal *generated.UserHistoryWhereInput return zeroVal, nil } ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOUserSettingWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserSettingWhereInput(ctx, tmp) + return ec.unmarshalOUserHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.UserSettingWhereInput + var zeroVal *generated.UserHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_user_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_userSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_user_argsID(ctx, rawArgs) + arg0, err := ec.field_Query_userSearch_argsQuery(ctx, rawArgs) if err != nil { return nil, err } - args["id"] = arg0 + args["query"] = arg0 return args, nil } -func (ec *executionContext) field_Query_user_argsID( +func (ec *executionContext) field_Query_userSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, ) (string, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. - _, ok := rawArgs["id"] + _, ok := rawArgs["query"] if !ok { var zeroVal string return zeroVal, nil } - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - if tmp, ok := rawArgs["id"]; ok { - return ec.unmarshalNID2string(ctx, tmp) + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) } var zeroVal string return zeroVal, nil } -func (ec *executionContext) field_Query_users_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_userSettingHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_users_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_userSettingHistories_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_users_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_userSettingHistories_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_users_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_userSettingHistories_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_users_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_userSettingHistories_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_users_argsOrderBy(ctx, rawArgs) - if err != nil { - return nil, err - } - args["orderBy"] = arg4 - arg5, err := ec.field_Query_users_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_userSettingHistories_argsWhere(ctx, rawArgs) if err != nil { return nil, err } - args["where"] = arg5 + args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_users_argsAfter( +func (ec *executionContext) field_Query_userSettingHistories_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84857,7 +86626,7 @@ func (ec *executionContext) field_Query_users_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_users_argsFirst( +func (ec *executionContext) field_Query_userSettingHistories_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84879,7 +86648,7 @@ func (ec *executionContext) field_Query_users_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_users_argsBefore( +func (ec *executionContext) field_Query_userSettingHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -84901,7 +86670,7 @@ func (ec *executionContext) field_Query_users_argsBefore( return zeroVal, nil } -func (ec *executionContext) field_Query_users_argsLast( +func (ec *executionContext) field_Query_userSettingHistories_argsLast( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -84923,86 +86692,123 @@ func (ec *executionContext) field_Query_users_argsLast( return zeroVal, nil } -func (ec *executionContext) field_Query_users_argsOrderBy( +func (ec *executionContext) field_Query_userSettingHistories_argsWhere( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.UserOrder, error) { +) (*generated.UserSettingHistoryWhereInput, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. - _, ok := rawArgs["orderBy"] + _, ok := rawArgs["where"] if !ok { - var zeroVal *generated.UserOrder + var zeroVal *generated.UserSettingHistoryWhereInput return zeroVal, nil } - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) - if tmp, ok := rawArgs["orderBy"]; ok { - return ec.unmarshalOUserOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserOrder(ctx, tmp) + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) + if tmp, ok := rawArgs["where"]; ok { + return ec.unmarshalOUserSettingHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserSettingHistoryWhereInput(ctx, tmp) } - var zeroVal *generated.UserOrder + var zeroVal *generated.UserSettingHistoryWhereInput return zeroVal, nil } -func (ec *executionContext) field_Query_users_argsWhere( +func (ec *executionContext) field_Query_userSettingSearch_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_userSettingSearch_argsQuery(ctx, rawArgs) + if err != nil { + return nil, err + } + args["query"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_userSettingSearch_argsQuery( ctx context.Context, rawArgs map[string]interface{}, -) (*generated.UserWhereInput, error) { +) (string, error) { // We won't call the directive if the argument is null. // Set call_argument_directives_with_null to true to call directives // even if the argument is null. - _, ok := rawArgs["where"] + _, ok := rawArgs["query"] if !ok { - var zeroVal *generated.UserWhereInput + var zeroVal string return zeroVal, nil } - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) - if tmp, ok := rawArgs["where"]; ok { - return ec.unmarshalOUserWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserWhereInput(ctx, tmp) + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("query")) + if tmp, ok := rawArgs["query"]; ok { + return ec.unmarshalNString2string(ctx, tmp) } - var zeroVal *generated.UserWhereInput + var zeroVal string return zeroVal, nil } -func (ec *executionContext) field_Query_webhookHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Query_userSetting_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Query_webhookHistories_argsAfter(ctx, rawArgs) + arg0, err := ec.field_Query_userSetting_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_userSetting_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_userSettings_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_userSettings_argsAfter(ctx, rawArgs) if err != nil { return nil, err } args["after"] = arg0 - arg1, err := ec.field_Query_webhookHistories_argsFirst(ctx, rawArgs) + arg1, err := ec.field_Query_userSettings_argsFirst(ctx, rawArgs) if err != nil { return nil, err } args["first"] = arg1 - arg2, err := ec.field_Query_webhookHistories_argsBefore(ctx, rawArgs) + arg2, err := ec.field_Query_userSettings_argsBefore(ctx, rawArgs) if err != nil { return nil, err } args["before"] = arg2 - arg3, err := ec.field_Query_webhookHistories_argsLast(ctx, rawArgs) + arg3, err := ec.field_Query_userSettings_argsLast(ctx, rawArgs) if err != nil { return nil, err } args["last"] = arg3 - arg4, err := ec.field_Query_webhookHistories_argsOrderBy(ctx, rawArgs) - if err != nil { - return nil, err - } - args["orderBy"] = arg4 - arg5, err := ec.field_Query_webhookHistories_argsWhere(ctx, rawArgs) + arg4, err := ec.field_Query_userSettings_argsWhere(ctx, rawArgs) if err != nil { return nil, err } - args["where"] = arg5 + args["where"] = arg4 return args, nil } -func (ec *executionContext) field_Query_webhookHistories_argsAfter( +func (ec *executionContext) field_Query_userSettings_argsAfter( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -85024,7 +86830,7 @@ func (ec *executionContext) field_Query_webhookHistories_argsAfter( return zeroVal, nil } -func (ec *executionContext) field_Query_webhookHistories_argsFirst( +func (ec *executionContext) field_Query_userSettings_argsFirst( ctx context.Context, rawArgs map[string]interface{}, ) (*int, error) { @@ -85046,7 +86852,351 @@ func (ec *executionContext) field_Query_webhookHistories_argsFirst( return zeroVal, nil } -func (ec *executionContext) field_Query_webhookHistories_argsBefore( +func (ec *executionContext) field_Query_userSettings_argsBefore( + ctx context.Context, + rawArgs map[string]interface{}, +) (*entgql.Cursor[string], error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["before"] + if !ok { + var zeroVal *entgql.Cursor[string] + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before")) + if tmp, ok := rawArgs["before"]; ok { + return ec.unmarshalOCursor2ᚖentgoᚗioᚋcontribᚋentgqlᚐCursor(ctx, tmp) + } + + var zeroVal *entgql.Cursor[string] + return zeroVal, nil +} + +func (ec *executionContext) field_Query_userSettings_argsLast( + ctx context.Context, + rawArgs map[string]interface{}, +) (*int, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["last"] + if !ok { + var zeroVal *int + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last")) + if tmp, ok := rawArgs["last"]; ok { + return ec.unmarshalOInt2ᚖint(ctx, tmp) + } + + var zeroVal *int + return zeroVal, nil +} + +func (ec *executionContext) field_Query_userSettings_argsWhere( + ctx context.Context, + rawArgs map[string]interface{}, +) (*generated.UserSettingWhereInput, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["where"] + if !ok { + var zeroVal *generated.UserSettingWhereInput + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) + if tmp, ok := rawArgs["where"]; ok { + return ec.unmarshalOUserSettingWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserSettingWhereInput(ctx, tmp) + } + + var zeroVal *generated.UserSettingWhereInput + return zeroVal, nil +} + +func (ec *executionContext) field_Query_user_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_user_argsID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["id"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_user_argsID( + ctx context.Context, + rawArgs map[string]interface{}, +) (string, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["id"] + if !ok { + var zeroVal string + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + if tmp, ok := rawArgs["id"]; ok { + return ec.unmarshalNID2string(ctx, tmp) + } + + var zeroVal string + return zeroVal, nil +} + +func (ec *executionContext) field_Query_users_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_users_argsAfter(ctx, rawArgs) + if err != nil { + return nil, err + } + args["after"] = arg0 + arg1, err := ec.field_Query_users_argsFirst(ctx, rawArgs) + if err != nil { + return nil, err + } + args["first"] = arg1 + arg2, err := ec.field_Query_users_argsBefore(ctx, rawArgs) + if err != nil { + return nil, err + } + args["before"] = arg2 + arg3, err := ec.field_Query_users_argsLast(ctx, rawArgs) + if err != nil { + return nil, err + } + args["last"] = arg3 + arg4, err := ec.field_Query_users_argsOrderBy(ctx, rawArgs) + if err != nil { + return nil, err + } + args["orderBy"] = arg4 + arg5, err := ec.field_Query_users_argsWhere(ctx, rawArgs) + if err != nil { + return nil, err + } + args["where"] = arg5 + return args, nil +} +func (ec *executionContext) field_Query_users_argsAfter( + ctx context.Context, + rawArgs map[string]interface{}, +) (*entgql.Cursor[string], error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["after"] + if !ok { + var zeroVal *entgql.Cursor[string] + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after")) + if tmp, ok := rawArgs["after"]; ok { + return ec.unmarshalOCursor2ᚖentgoᚗioᚋcontribᚋentgqlᚐCursor(ctx, tmp) + } + + var zeroVal *entgql.Cursor[string] + return zeroVal, nil +} + +func (ec *executionContext) field_Query_users_argsFirst( + ctx context.Context, + rawArgs map[string]interface{}, +) (*int, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["first"] + if !ok { + var zeroVal *int + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first")) + if tmp, ok := rawArgs["first"]; ok { + return ec.unmarshalOInt2ᚖint(ctx, tmp) + } + + var zeroVal *int + return zeroVal, nil +} + +func (ec *executionContext) field_Query_users_argsBefore( + ctx context.Context, + rawArgs map[string]interface{}, +) (*entgql.Cursor[string], error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["before"] + if !ok { + var zeroVal *entgql.Cursor[string] + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before")) + if tmp, ok := rawArgs["before"]; ok { + return ec.unmarshalOCursor2ᚖentgoᚗioᚋcontribᚋentgqlᚐCursor(ctx, tmp) + } + + var zeroVal *entgql.Cursor[string] + return zeroVal, nil +} + +func (ec *executionContext) field_Query_users_argsLast( + ctx context.Context, + rawArgs map[string]interface{}, +) (*int, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["last"] + if !ok { + var zeroVal *int + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last")) + if tmp, ok := rawArgs["last"]; ok { + return ec.unmarshalOInt2ᚖint(ctx, tmp) + } + + var zeroVal *int + return zeroVal, nil +} + +func (ec *executionContext) field_Query_users_argsOrderBy( + ctx context.Context, + rawArgs map[string]interface{}, +) (*generated.UserOrder, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["orderBy"] + if !ok { + var zeroVal *generated.UserOrder + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("orderBy")) + if tmp, ok := rawArgs["orderBy"]; ok { + return ec.unmarshalOUserOrder2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserOrder(ctx, tmp) + } + + var zeroVal *generated.UserOrder + return zeroVal, nil +} + +func (ec *executionContext) field_Query_users_argsWhere( + ctx context.Context, + rawArgs map[string]interface{}, +) (*generated.UserWhereInput, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["where"] + if !ok { + var zeroVal *generated.UserWhereInput + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("where")) + if tmp, ok := rawArgs["where"]; ok { + return ec.unmarshalOUserWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserWhereInput(ctx, tmp) + } + + var zeroVal *generated.UserWhereInput + return zeroVal, nil +} + +func (ec *executionContext) field_Query_webhookHistories_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_webhookHistories_argsAfter(ctx, rawArgs) + if err != nil { + return nil, err + } + args["after"] = arg0 + arg1, err := ec.field_Query_webhookHistories_argsFirst(ctx, rawArgs) + if err != nil { + return nil, err + } + args["first"] = arg1 + arg2, err := ec.field_Query_webhookHistories_argsBefore(ctx, rawArgs) + if err != nil { + return nil, err + } + args["before"] = arg2 + arg3, err := ec.field_Query_webhookHistories_argsLast(ctx, rawArgs) + if err != nil { + return nil, err + } + args["last"] = arg3 + arg4, err := ec.field_Query_webhookHistories_argsOrderBy(ctx, rawArgs) + if err != nil { + return nil, err + } + args["orderBy"] = arg4 + arg5, err := ec.field_Query_webhookHistories_argsWhere(ctx, rawArgs) + if err != nil { + return nil, err + } + args["where"] = arg5 + return args, nil +} +func (ec *executionContext) field_Query_webhookHistories_argsAfter( + ctx context.Context, + rawArgs map[string]interface{}, +) (*entgql.Cursor[string], error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["after"] + if !ok { + var zeroVal *entgql.Cursor[string] + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after")) + if tmp, ok := rawArgs["after"]; ok { + return ec.unmarshalOCursor2ᚖentgoᚗioᚋcontribᚋentgqlᚐCursor(ctx, tmp) + } + + var zeroVal *entgql.Cursor[string] + return zeroVal, nil +} + +func (ec *executionContext) field_Query_webhookHistories_argsFirst( + ctx context.Context, + rawArgs map[string]interface{}, +) (*int, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["first"] + if !ok { + var zeroVal *int + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first")) + if tmp, ok := rawArgs["first"]; ok { + return ec.unmarshalOInt2ᚖint(ctx, tmp) + } + + var zeroVal *int + return zeroVal, nil +} + +func (ec *executionContext) field_Query_webhookHistories_argsBefore( ctx context.Context, rawArgs map[string]interface{}, ) (*entgql.Cursor[string], error) { @@ -86159,6 +88309,8 @@ func (ec *executionContext) fieldContext_APIToken_owner(_ context.Context, field return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -90910,6 +93062,8 @@ func (ec *executionContext) fieldContext_Contact_owner(_ context.Context, field return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -93844,6 +95998,8 @@ func (ec *executionContext) fieldContext_Control_owner(_ context.Context, field return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -97985,6 +100141,8 @@ func (ec *executionContext) fieldContext_ControlObjective_owner(_ context.Contex return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -102165,6 +104323,8 @@ func (ec *executionContext) fieldContext_DocumentData_owner(_ context.Context, f return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -104851,6 +107011,8 @@ func (ec *executionContext) fieldContext_Entitlement_owner(_ context.Context, fi return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -105103,6 +107265,8 @@ func (ec *executionContext) fieldContext_Entitlement_organization(_ context.Cont return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -107734,6 +109898,8 @@ func (ec *executionContext) fieldContext_EntitlementPlan_owner(_ context.Context return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -109315,6 +111481,8 @@ func (ec *executionContext) fieldContext_EntitlementPlanFeature_owner(_ context. return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -113393,6 +115561,8 @@ func (ec *executionContext) fieldContext_Entity_owner(_ context.Context, field g return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -115960,6 +118130,8 @@ func (ec *executionContext) fieldContext_EntityType_owner(_ context.Context, fie return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -118422,6 +120594,8 @@ func (ec *executionContext) fieldContext_Event_organization(_ context.Context, f return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -121767,6 +123941,8 @@ func (ec *executionContext) fieldContext_Feature_owner(_ context.Context, field return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -124842,6 +127018,8 @@ func (ec *executionContext) fieldContext_File_organization(_ context.Context, fi return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -128146,6 +130324,8 @@ func (ec *executionContext) fieldContext_Group_owner(_ context.Context, field gr return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -128307,6 +130487,8 @@ func (ec *executionContext) fieldContext_Group_controlCreators(_ context.Context return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -128468,6 +130650,8 @@ func (ec *executionContext) fieldContext_Group_controlObjectiveCreators(_ contex return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -128629,6 +130813,8 @@ func (ec *executionContext) fieldContext_Group_groupCreators(_ context.Context, return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -128790,6 +130976,8 @@ func (ec *executionContext) fieldContext_Group_internalPolicyCreators(_ context. return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -128951,6 +131139,8 @@ func (ec *executionContext) fieldContext_Group_narrativeCreators(_ context.Conte return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -129112,6 +131302,8 @@ func (ec *executionContext) fieldContext_Group_procedureCreators(_ context.Conte return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -129273,6 +131465,8 @@ func (ec *executionContext) fieldContext_Group_programCreators(_ context.Context return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -129434,6 +131628,8 @@ func (ec *executionContext) fieldContext_Group_riskCreators(_ context.Context, f return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -129595,6 +131791,8 @@ func (ec *executionContext) fieldContext_Group_templateCreators(_ context.Contex return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -139108,6 +141306,8 @@ func (ec *executionContext) fieldContext_Hush_organization(_ context.Context, fi return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -141233,6 +143433,8 @@ func (ec *executionContext) fieldContext_Integration_owner(_ context.Context, fi return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -143934,6 +146136,8 @@ func (ec *executionContext) fieldContext_InternalPolicy_owner(_ context.Context, return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -147396,6 +149600,8 @@ func (ec *executionContext) fieldContext_Invite_owner(_ context.Context, field g return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -155824,6 +158030,301 @@ func (ec *executionContext) fieldContext_Mutation_deleteOrgMembership(ctx contex return fc, nil } +func (ec *executionContext) _Mutation_createOrgSubscription(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Mutation_createOrgSubscription(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Mutation().CreateOrgSubscription(rctx, fc.Args["input"].(generated.CreateOrgSubscriptionInput)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*OrgSubscriptionCreatePayload) + fc.Result = res + return ec.marshalNOrgSubscriptionCreatePayload2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionCreatePayload(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Mutation_createOrgSubscription(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "orgSubscription": + return ec.fieldContext_OrgSubscriptionCreatePayload_orgSubscription(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionCreatePayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_createOrgSubscription_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Mutation_createBulkOrgSubscription(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Mutation_createBulkOrgSubscription(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Mutation().CreateBulkOrgSubscription(rctx, fc.Args["input"].([]*generated.CreateOrgSubscriptionInput)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*OrgSubscriptionBulkCreatePayload) + fc.Result = res + return ec.marshalNOrgSubscriptionBulkCreatePayload2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionBulkCreatePayload(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Mutation_createBulkOrgSubscription(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "orgSubscriptions": + return ec.fieldContext_OrgSubscriptionBulkCreatePayload_orgSubscriptions(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionBulkCreatePayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_createBulkOrgSubscription_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Mutation_createBulkCSVOrgSubscription(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Mutation_createBulkCSVOrgSubscription(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Mutation().CreateBulkCSVOrgSubscription(rctx, fc.Args["input"].(graphql.Upload)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*OrgSubscriptionBulkCreatePayload) + fc.Result = res + return ec.marshalNOrgSubscriptionBulkCreatePayload2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionBulkCreatePayload(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Mutation_createBulkCSVOrgSubscription(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "orgSubscriptions": + return ec.fieldContext_OrgSubscriptionBulkCreatePayload_orgSubscriptions(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionBulkCreatePayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_createBulkCSVOrgSubscription_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Mutation_updateOrgSubscription(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Mutation_updateOrgSubscription(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Mutation().UpdateOrgSubscription(rctx, fc.Args["id"].(string), fc.Args["input"].(generated.UpdateOrgSubscriptionInput)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*OrgSubscriptionUpdatePayload) + fc.Result = res + return ec.marshalNOrgSubscriptionUpdatePayload2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionUpdatePayload(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Mutation_updateOrgSubscription(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "orgSubscription": + return ec.fieldContext_OrgSubscriptionUpdatePayload_orgSubscription(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionUpdatePayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_updateOrgSubscription_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Mutation_deleteOrgSubscription(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Mutation_deleteOrgSubscription(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Mutation().DeleteOrgSubscription(rctx, fc.Args["id"].(string)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*OrgSubscriptionDeletePayload) + fc.Result = res + return ec.marshalNOrgSubscriptionDeletePayload2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionDeletePayload(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Mutation_deleteOrgSubscription(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Mutation", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "deletedID": + return ec.fieldContext_OrgSubscriptionDeletePayload_deletedID(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionDeletePayload", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Mutation_deleteOrgSubscription_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Mutation_createPersonalAccessToken(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { fc, err := ec.fieldContext_Mutation_createPersonalAccessToken(ctx, field) if err != nil { @@ -160420,6 +162921,8 @@ func (ec *executionContext) fieldContext_Narrative_owner(_ context.Context, fiel return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -163560,6 +166063,8 @@ func (ec *executionContext) fieldContext_Note_owner(_ context.Context, field gra return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -165855,6 +168360,8 @@ func (ec *executionContext) fieldContext_OauthProvider_owner(_ context.Context, return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -169648,6 +172155,8 @@ func (ec *executionContext) fieldContext_OrgMembership_organization(_ context.Co return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -171250,8 +173759,8 @@ func (ec *executionContext) fieldContext_OrgMembershipUpdatePayload_orgMembershi return fc, nil } -func (ec *executionContext) _Organization_id(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_id(ctx, field) +func (ec *executionContext) _OrgSubscription_id(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_id(ctx, field) if err != nil { return graphql.Null } @@ -171281,9 +173790,9 @@ func (ec *executionContext) _Organization_id(ctx context.Context, field graphql. return ec.marshalNID2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171294,8 +173803,8 @@ func (ec *executionContext) fieldContext_Organization_id(_ context.Context, fiel return fc, nil } -func (ec *executionContext) _Organization_createdAt(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_createdAt(ctx, field) +func (ec *executionContext) _OrgSubscription_createdAt(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_createdAt(ctx, field) if err != nil { return graphql.Null } @@ -171322,9 +173831,9 @@ func (ec *executionContext) _Organization_createdAt(ctx context.Context, field g return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171335,8 +173844,8 @@ func (ec *executionContext) fieldContext_Organization_createdAt(_ context.Contex return fc, nil } -func (ec *executionContext) _Organization_updatedAt(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_updatedAt(ctx, field) +func (ec *executionContext) _OrgSubscription_updatedAt(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_updatedAt(ctx, field) if err != nil { return graphql.Null } @@ -171363,9 +173872,9 @@ func (ec *executionContext) _Organization_updatedAt(ctx context.Context, field g return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171376,8 +173885,8 @@ func (ec *executionContext) fieldContext_Organization_updatedAt(_ context.Contex return fc, nil } -func (ec *executionContext) _Organization_createdBy(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_createdBy(ctx, field) +func (ec *executionContext) _OrgSubscription_createdBy(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_createdBy(ctx, field) if err != nil { return graphql.Null } @@ -171404,9 +173913,9 @@ func (ec *executionContext) _Organization_createdBy(ctx context.Context, field g return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_createdBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_createdBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171417,8 +173926,8 @@ func (ec *executionContext) fieldContext_Organization_createdBy(_ context.Contex return fc, nil } -func (ec *executionContext) _Organization_updatedBy(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_updatedBy(ctx, field) +func (ec *executionContext) _OrgSubscription_updatedBy(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_updatedBy(ctx, field) if err != nil { return graphql.Null } @@ -171445,9 +173954,9 @@ func (ec *executionContext) _Organization_updatedBy(ctx context.Context, field g return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_updatedBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_updatedBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171458,8 +173967,8 @@ func (ec *executionContext) fieldContext_Organization_updatedBy(_ context.Contex return fc, nil } -func (ec *executionContext) _Organization_tags(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_tags(ctx, field) +func (ec *executionContext) _OrgSubscription_tags(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_tags(ctx, field) if err != nil { return graphql.Null } @@ -171486,9 +173995,9 @@ func (ec *executionContext) _Organization_tags(ctx context.Context, field graphq return ec.marshalOString2ᚕstringᚄ(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_tags(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_tags(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171499,8 +174008,8 @@ func (ec *executionContext) fieldContext_Organization_tags(_ context.Context, fi return fc, nil } -func (ec *executionContext) _Organization_deletedAt(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_deletedAt(ctx, field) +func (ec *executionContext) _OrgSubscription_deletedAt(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_deletedAt(ctx, field) if err != nil { return graphql.Null } @@ -171527,9 +174036,9 @@ func (ec *executionContext) _Organization_deletedAt(ctx context.Context, field g return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_deletedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_deletedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171540,8 +174049,8 @@ func (ec *executionContext) fieldContext_Organization_deletedAt(_ context.Contex return fc, nil } -func (ec *executionContext) _Organization_deletedBy(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_deletedBy(ctx, field) +func (ec *executionContext) _OrgSubscription_deletedBy(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_deletedBy(ctx, field) if err != nil { return graphql.Null } @@ -171568,9 +174077,9 @@ func (ec *executionContext) _Organization_deletedBy(ctx context.Context, field g return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_deletedBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_deletedBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171581,8 +174090,8 @@ func (ec *executionContext) fieldContext_Organization_deletedBy(_ context.Contex return fc, nil } -func (ec *executionContext) _Organization_name(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_name(ctx, field) +func (ec *executionContext) _OrgSubscription_ownerID(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_ownerID(ctx, field) if err != nil { return graphql.Null } @@ -171595,38 +174104,35 @@ func (ec *executionContext) _Organization_name(ctx context.Context, field graphq }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Name, nil + return obj.OwnerID, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { - if !graphql.HasFieldError(ctx, fc) { - ec.Errorf(ctx, "must not be null") - } return graphql.Null } res := resTmp.(string) fc.Result = res - return ec.marshalNString2string(ctx, field.Selections, res) + return ec.marshalOID2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_ownerID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type String does not have child fields") + return nil, errors.New("field of type ID does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_displayName(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_displayName(ctx, field) +func (ec *executionContext) _OrgSubscription_stripeSubscriptionID(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_stripeSubscriptionID(ctx, field) if err != nil { return graphql.Null } @@ -171639,26 +174145,23 @@ func (ec *executionContext) _Organization_displayName(ctx context.Context, field }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.DisplayName, nil + return obj.StripeSubscriptionID, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { - if !graphql.HasFieldError(ctx, fc) { - ec.Errorf(ctx, "must not be null") - } return graphql.Null } res := resTmp.(string) fc.Result = res - return ec.marshalNString2string(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_displayName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_stripeSubscriptionID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171669,8 +174172,8 @@ func (ec *executionContext) fieldContext_Organization_displayName(_ context.Cont return fc, nil } -func (ec *executionContext) _Organization_description(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_description(ctx, field) +func (ec *executionContext) _OrgSubscription_productTier(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_productTier(ctx, field) if err != nil { return graphql.Null } @@ -171683,7 +174186,7 @@ func (ec *executionContext) _Organization_description(ctx context.Context, field }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Description, nil + return obj.ProductTier, nil }) if err != nil { ec.Error(ctx, err) @@ -171697,9 +174200,9 @@ func (ec *executionContext) _Organization_description(ctx context.Context, field return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_productTier(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171710,8 +174213,8 @@ func (ec *executionContext) fieldContext_Organization_description(_ context.Cont return fc, nil } -func (ec *executionContext) _Organization_personalOrg(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_personalOrg(ctx, field) +func (ec *executionContext) _OrgSubscription_stripeProductTierID(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_stripeProductTierID(ctx, field) if err != nil { return graphql.Null } @@ -171724,7 +174227,7 @@ func (ec *executionContext) _Organization_personalOrg(ctx context.Context, field }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.PersonalOrg, nil + return obj.StripeProductTierID, nil }) if err != nil { ec.Error(ctx, err) @@ -171733,26 +174236,26 @@ func (ec *executionContext) _Organization_personalOrg(ctx context.Context, field if resTmp == nil { return graphql.Null } - res := resTmp.(bool) + res := resTmp.(string) fc.Result = res - return ec.marshalOBoolean2bool(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_personalOrg(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_stripeProductTierID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Boolean does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_avatarRemoteURL(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_avatarRemoteURL(ctx, field) +func (ec *executionContext) _OrgSubscription_stripeSubscriptionStatus(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_stripeSubscriptionStatus(ctx, field) if err != nil { return graphql.Null } @@ -171765,7 +174268,7 @@ func (ec *executionContext) _Organization_avatarRemoteURL(ctx context.Context, f }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.AvatarRemoteURL, nil + return obj.StripeSubscriptionStatus, nil }) if err != nil { ec.Error(ctx, err) @@ -171774,14 +174277,14 @@ func (ec *executionContext) _Organization_avatarRemoteURL(ctx context.Context, f if resTmp == nil { return graphql.Null } - res := resTmp.(*string) + res := resTmp.(string) fc.Result = res - return ec.marshalOString2ᚖstring(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_avatarRemoteURL(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_stripeSubscriptionStatus(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171792,8 +174295,8 @@ func (ec *executionContext) fieldContext_Organization_avatarRemoteURL(_ context. return fc, nil } -func (ec *executionContext) _Organization_dedicatedDb(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_dedicatedDb(ctx, field) +func (ec *executionContext) _OrgSubscription_active(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_active(ctx, field) if err != nil { return graphql.Null } @@ -171806,7 +174309,7 @@ func (ec *executionContext) _Organization_dedicatedDb(ctx context.Context, field }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.DedicatedDb, nil + return obj.Active, nil }) if err != nil { ec.Error(ctx, err) @@ -171823,9 +174326,9 @@ func (ec *executionContext) _Organization_dedicatedDb(ctx context.Context, field return ec.marshalNBoolean2bool(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_dedicatedDb(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_active(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: false, IsResolver: false, @@ -171836,8 +174339,8 @@ func (ec *executionContext) fieldContext_Organization_dedicatedDb(_ context.Cont return fc, nil } -func (ec *executionContext) _Organization_controlCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_controlCreators(ctx, field) +func (ec *executionContext) _OrgSubscription_stripeCustomerID(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_stripeCustomerID(ctx, field) if err != nil { return graphql.Null } @@ -171850,7 +174353,7 @@ func (ec *executionContext) _Organization_controlCreators(ctx context.Context, f }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.ControlCreators(ctx) + return obj.StripeCustomerID, nil }) if err != nil { ec.Error(ctx, err) @@ -171859,128 +174362,26 @@ func (ec *executionContext) _Organization_controlCreators(ctx context.Context, f if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.(string) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_controlCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_stripeCustomerID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Group_id(ctx, field) - case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) - case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) - case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) - case "owner": - return ec.fieldContext_Group_owner(ctx, field) - case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) - case "setting": - return ec.fieldContext_Group_setting(ctx, field) - case "users": - return ec.fieldContext_Group_users(ctx, field) - case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) - case "files": - return ec.fieldContext_Group_files(ctx, field) - case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) - case "members": - return ec.fieldContext_Group_members(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_controlObjectiveCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_controlObjectiveCreators(ctx, field) +func (ec *executionContext) _OrgSubscription_expiresAt(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_expiresAt(ctx, field) if err != nil { return graphql.Null } @@ -171993,7 +174394,7 @@ func (ec *executionContext) _Organization_controlObjectiveCreators(ctx context.C }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.ControlObjectiveCreators(ctx) + return obj.ExpiresAt, nil }) if err != nil { ec.Error(ctx, err) @@ -172002,128 +174403,26 @@ func (ec *executionContext) _Organization_controlObjectiveCreators(ctx context.C if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.(*time.Time) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_controlObjectiveCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_expiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Group_id(ctx, field) - case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) - case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) - case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) - case "owner": - return ec.fieldContext_Group_owner(ctx, field) - case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) - case "setting": - return ec.fieldContext_Group_setting(ctx, field) - case "users": - return ec.fieldContext_Group_users(ctx, field) - case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) - case "files": - return ec.fieldContext_Group_files(ctx, field) - case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) - case "members": - return ec.fieldContext_Group_members(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_groupCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_groupCreators(ctx, field) +func (ec *executionContext) _OrgSubscription_features(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_features(ctx, field) if err != nil { return graphql.Null } @@ -172136,7 +174435,7 @@ func (ec *executionContext) _Organization_groupCreators(ctx context.Context, fie }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.GroupCreators(ctx) + return obj.Features, nil }) if err != nil { ec.Error(ctx, err) @@ -172145,128 +174444,26 @@ func (ec *executionContext) _Organization_groupCreators(ctx context.Context, fie if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.([]string) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalOString2ᚕstringᚄ(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_groupCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_features(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Group_id(ctx, field) - case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) - case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) - case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) - case "owner": - return ec.fieldContext_Group_owner(ctx, field) - case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) - case "setting": - return ec.fieldContext_Group_setting(ctx, field) - case "users": - return ec.fieldContext_Group_users(ctx, field) - case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) - case "files": - return ec.fieldContext_Group_files(ctx, field) - case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) - case "members": - return ec.fieldContext_Group_members(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_internalPolicyCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_internalPolicyCreators(ctx, field) +func (ec *executionContext) _OrgSubscription_owner(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscription) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscription_owner(ctx, field) if err != nil { return graphql.Null } @@ -172279,7 +174476,7 @@ func (ec *executionContext) _Organization_internalPolicyCreators(ctx context.Con }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.InternalPolicyCreators(ctx) + return obj.Owner(ctx) }) if err != nil { ec.Error(ctx, err) @@ -172288,128 +174485,148 @@ func (ec *executionContext) _Organization_internalPolicyCreators(ctx context.Con if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.(*generated.Organization) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalOOrganization2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganization(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_internalPolicyCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscription_owner(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscription", Field: field, IsMethod: true, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "id": - return ec.fieldContext_Group_id(ctx, field) + return ec.fieldContext_Organization_id(ctx, field) case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) + return ec.fieldContext_Organization_createdAt(ctx, field) case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) + return ec.fieldContext_Organization_updatedAt(ctx, field) case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) + return ec.fieldContext_Organization_createdBy(ctx, field) case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) + return ec.fieldContext_Organization_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_Organization_tags(ctx, field) case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) + return ec.fieldContext_Organization_deletedAt(ctx, field) case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) + return ec.fieldContext_Organization_deletedBy(ctx, field) case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) + return ec.fieldContext_Organization_name(ctx, field) case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) - case "owner": - return ec.fieldContext_Group_owner(ctx, field) + return ec.fieldContext_Organization_displayName(ctx, field) + case "description": + return ec.fieldContext_Organization_description(ctx, field) + case "personalOrg": + return ec.fieldContext_Organization_personalOrg(ctx, field) + case "avatarRemoteURL": + return ec.fieldContext_Organization_avatarRemoteURL(ctx, field) + case "dedicatedDb": + return ec.fieldContext_Organization_dedicatedDb(ctx, field) case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) + return ec.fieldContext_Organization_controlCreators(ctx, field) case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + return ec.fieldContext_Organization_controlObjectiveCreators(ctx, field) case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) + return ec.fieldContext_Organization_groupCreators(ctx, field) case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + return ec.fieldContext_Organization_internalPolicyCreators(ctx, field) case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) + return ec.fieldContext_Organization_narrativeCreators(ctx, field) case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) + return ec.fieldContext_Organization_procedureCreators(ctx, field) case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) + return ec.fieldContext_Organization_programCreators(ctx, field) case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) + return ec.fieldContext_Organization_riskCreators(ctx, field) case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) + return ec.fieldContext_Organization_templateCreators(ctx, field) + case "parent": + return ec.fieldContext_Organization_parent(ctx, field) + case "children": + return ec.fieldContext_Organization_children(ctx, field) + case "groups": + return ec.fieldContext_Organization_groups(ctx, field) + case "templates": + return ec.fieldContext_Organization_templates(ctx, field) + case "integrations": + return ec.fieldContext_Organization_integrations(ctx, field) case "setting": - return ec.fieldContext_Group_setting(ctx, field) + return ec.fieldContext_Organization_setting(ctx, field) + case "documentdata": + return ec.fieldContext_Organization_documentdata(ctx, field) + case "entitlements": + return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) + case "organizationEntitlement": + return ec.fieldContext_Organization_organizationEntitlement(ctx, field) + case "personalAccessTokens": + return ec.fieldContext_Organization_personalAccessTokens(ctx, field) + case "apiTokens": + return ec.fieldContext_Organization_apiTokens(ctx, field) + case "oauthprovider": + return ec.fieldContext_Organization_oauthprovider(ctx, field) case "users": - return ec.fieldContext_Group_users(ctx, field) + return ec.fieldContext_Organization_users(ctx, field) + case "invites": + return ec.fieldContext_Organization_invites(ctx, field) + case "subscribers": + return ec.fieldContext_Organization_subscribers(ctx, field) + case "webhooks": + return ec.fieldContext_Organization_webhooks(ctx, field) case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) + return ec.fieldContext_Organization_events(ctx, field) + case "secrets": + return ec.fieldContext_Organization_secrets(ctx, field) + case "features": + return ec.fieldContext_Organization_features(ctx, field) case "files": - return ec.fieldContext_Group_files(ctx, field) + return ec.fieldContext_Organization_files(ctx, field) + case "entitlementplans": + return ec.fieldContext_Organization_entitlementplans(ctx, field) + case "entitlementplanfeatures": + return ec.fieldContext_Organization_entitlementplanfeatures(ctx, field) + case "entities": + return ec.fieldContext_Organization_entities(ctx, field) + case "entitytypes": + return ec.fieldContext_Organization_entitytypes(ctx, field) + case "contacts": + return ec.fieldContext_Organization_contacts(ctx, field) + case "notes": + return ec.fieldContext_Organization_notes(ctx, field) case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) + return ec.fieldContext_Organization_tasks(ctx, field) + case "programs": + return ec.fieldContext_Organization_programs(ctx, field) + case "procedures": + return ec.fieldContext_Organization_procedures(ctx, field) + case "internalpolicies": + return ec.fieldContext_Organization_internalpolicies(ctx, field) + case "risks": + return ec.fieldContext_Organization_risks(ctx, field) + case "controlobjectives": + return ec.fieldContext_Organization_controlobjectives(ctx, field) + case "narratives": + return ec.fieldContext_Organization_narratives(ctx, field) + case "controls": + return ec.fieldContext_Organization_controls(ctx, field) + case "subcontrols": + return ec.fieldContext_Organization_subcontrols(ctx, field) case "members": - return ec.fieldContext_Group_members(ctx, field) + return ec.fieldContext_Organization_members(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_narrativeCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_narrativeCreators(ctx, field) +func (ec *executionContext) _OrgSubscriptionBulkCreatePayload_orgSubscriptions(ctx context.Context, field graphql.CollectedField, obj *OrgSubscriptionBulkCreatePayload) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionBulkCreatePayload_orgSubscriptions(ctx, field) if err != nil { return graphql.Null } @@ -172422,7 +174639,7 @@ func (ec *executionContext) _Organization_narrativeCreators(ctx context.Context, }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.NarrativeCreators(ctx) + return obj.OrgSubscriptions, nil }) if err != nil { ec.Error(ctx, err) @@ -172431,128 +174648,64 @@ func (ec *executionContext) _Organization_narrativeCreators(ctx context.Context, if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.([]*generated.OrgSubscription) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalOOrgSubscription2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionᚄ(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_narrativeCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionBulkCreatePayload_orgSubscriptions(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionBulkCreatePayload", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "id": - return ec.fieldContext_Group_id(ctx, field) + return ec.fieldContext_OrgSubscription_id(ctx, field) case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) + return ec.fieldContext_OrgSubscription_createdAt(ctx, field) case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) + return ec.fieldContext_OrgSubscription_updatedAt(ctx, field) case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) + return ec.fieldContext_OrgSubscription_createdBy(ctx, field) case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) + return ec.fieldContext_OrgSubscription_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_OrgSubscription_tags(ctx, field) case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) + return ec.fieldContext_OrgSubscription_deletedAt(ctx, field) case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) + return ec.fieldContext_OrgSubscription_deletedBy(ctx, field) case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) - case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) - case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) + return ec.fieldContext_OrgSubscription_ownerID(ctx, field) + case "stripeSubscriptionID": + return ec.fieldContext_OrgSubscription_stripeSubscriptionID(ctx, field) + case "productTier": + return ec.fieldContext_OrgSubscription_productTier(ctx, field) + case "stripeProductTierID": + return ec.fieldContext_OrgSubscription_stripeProductTierID(ctx, field) + case "stripeSubscriptionStatus": + return ec.fieldContext_OrgSubscription_stripeSubscriptionStatus(ctx, field) + case "active": + return ec.fieldContext_OrgSubscription_active(ctx, field) + case "stripeCustomerID": + return ec.fieldContext_OrgSubscription_stripeCustomerID(ctx, field) + case "expiresAt": + return ec.fieldContext_OrgSubscription_expiresAt(ctx, field) + case "features": + return ec.fieldContext_OrgSubscription_features(ctx, field) case "owner": - return ec.fieldContext_Group_owner(ctx, field) - case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) - case "setting": - return ec.fieldContext_Group_setting(ctx, field) - case "users": - return ec.fieldContext_Group_users(ctx, field) - case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) - case "files": - return ec.fieldContext_Group_files(ctx, field) - case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) - case "members": - return ec.fieldContext_Group_members(ctx, field) + return ec.fieldContext_OrgSubscription_owner(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, fmt.Errorf("no field named %q was found under type OrgSubscription", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_procedureCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_procedureCreators(ctx, field) +func (ec *executionContext) _OrgSubscriptionConnection_edges(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionConnection) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionConnection_edges(ctx, field) if err != nil { return graphql.Null } @@ -172565,7 +174718,7 @@ func (ec *executionContext) _Organization_procedureCreators(ctx context.Context, }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.ProcedureCreators(ctx) + return obj.Edges, nil }) if err != nil { ec.Error(ctx, err) @@ -172574,128 +174727,32 @@ func (ec *executionContext) _Organization_procedureCreators(ctx context.Context, if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.([]*generated.OrgSubscriptionEdge) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalOOrgSubscriptionEdge2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionEdge(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_procedureCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "id": - return ec.fieldContext_Group_id(ctx, field) - case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) - case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) - case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) - case "owner": - return ec.fieldContext_Group_owner(ctx, field) - case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) - case "setting": - return ec.fieldContext_Group_setting(ctx, field) - case "users": - return ec.fieldContext_Group_users(ctx, field) - case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) - case "files": - return ec.fieldContext_Group_files(ctx, field) - case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) - case "members": - return ec.fieldContext_Group_members(ctx, field) + case "node": + return ec.fieldContext_OrgSubscriptionEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_OrgSubscriptionEdge_cursor(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_programCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_programCreators(ctx, field) +func (ec *executionContext) _OrgSubscriptionConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionConnection) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionConnection_pageInfo(ctx, field) if err != nil { return graphql.Null } @@ -172708,137 +174765,48 @@ func (ec *executionContext) _Organization_programCreators(ctx context.Context, f }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.ProgramCreators(ctx) + return obj.PageInfo, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.(entgql.PageInfo[string]) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalNPageInfo2entgoᚗioᚋcontribᚋentgqlᚐPageInfo(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_programCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "id": - return ec.fieldContext_Group_id(ctx, field) - case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) - case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) - case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) - case "owner": - return ec.fieldContext_Group_owner(ctx, field) - case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) - case "setting": - return ec.fieldContext_Group_setting(ctx, field) - case "users": - return ec.fieldContext_Group_users(ctx, field) - case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) - case "files": - return ec.fieldContext_Group_files(ctx, field) - case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) - case "members": - return ec.fieldContext_Group_members(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_riskCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_riskCreators(ctx, field) +func (ec *executionContext) _OrgSubscriptionConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionConnection) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionConnection_totalCount(ctx, field) if err != nil { return graphql.Null } @@ -172851,137 +174819,120 @@ func (ec *executionContext) _Organization_riskCreators(ctx context.Context, fiel }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.RiskCreators(ctx) + return obj.TotalCount, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.(int) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalNInt2int(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_riskCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionConnection", Field: field, - IsMethod: true, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Int does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _OrgSubscriptionCreatePayload_orgSubscription(ctx context.Context, field graphql.CollectedField, obj *OrgSubscriptionCreatePayload) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionCreatePayload_orgSubscription(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.OrgSubscription, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*generated.OrgSubscription) + fc.Result = res + return ec.marshalNOrgSubscription2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscription(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_OrgSubscriptionCreatePayload_orgSubscription(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "OrgSubscriptionCreatePayload", + Field: field, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "id": - return ec.fieldContext_Group_id(ctx, field) + return ec.fieldContext_OrgSubscription_id(ctx, field) case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) + return ec.fieldContext_OrgSubscription_createdAt(ctx, field) case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) + return ec.fieldContext_OrgSubscription_updatedAt(ctx, field) case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) + return ec.fieldContext_OrgSubscription_createdBy(ctx, field) case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) + return ec.fieldContext_OrgSubscription_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_OrgSubscription_tags(ctx, field) case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) + return ec.fieldContext_OrgSubscription_deletedAt(ctx, field) case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) + return ec.fieldContext_OrgSubscription_deletedBy(ctx, field) case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) - case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) - case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) + return ec.fieldContext_OrgSubscription_ownerID(ctx, field) + case "stripeSubscriptionID": + return ec.fieldContext_OrgSubscription_stripeSubscriptionID(ctx, field) + case "productTier": + return ec.fieldContext_OrgSubscription_productTier(ctx, field) + case "stripeProductTierID": + return ec.fieldContext_OrgSubscription_stripeProductTierID(ctx, field) + case "stripeSubscriptionStatus": + return ec.fieldContext_OrgSubscription_stripeSubscriptionStatus(ctx, field) + case "active": + return ec.fieldContext_OrgSubscription_active(ctx, field) + case "stripeCustomerID": + return ec.fieldContext_OrgSubscription_stripeCustomerID(ctx, field) + case "expiresAt": + return ec.fieldContext_OrgSubscription_expiresAt(ctx, field) + case "features": + return ec.fieldContext_OrgSubscription_features(ctx, field) case "owner": - return ec.fieldContext_Group_owner(ctx, field) - case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) - case "setting": - return ec.fieldContext_Group_setting(ctx, field) - case "users": - return ec.fieldContext_Group_users(ctx, field) - case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) - case "files": - return ec.fieldContext_Group_files(ctx, field) - case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) - case "members": - return ec.fieldContext_Group_members(ctx, field) + return ec.fieldContext_OrgSubscription_owner(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, fmt.Errorf("no field named %q was found under type OrgSubscription", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_templateCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_templateCreators(ctx, field) +func (ec *executionContext) _OrgSubscriptionDeletePayload_deletedID(ctx context.Context, field graphql.CollectedField, obj *OrgSubscriptionDeletePayload) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionDeletePayload_deletedID(ctx, field) if err != nil { return graphql.Null } @@ -172994,137 +174945,38 @@ func (ec *executionContext) _Organization_templateCreators(ctx context.Context, }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.TemplateCreators(ctx) + return obj.DeletedID, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.(string) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalNID2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_templateCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionDeletePayload_deletedID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionDeletePayload", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Group_id(ctx, field) - case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) - case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) - case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) - case "owner": - return ec.fieldContext_Group_owner(ctx, field) - case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) - case "setting": - return ec.fieldContext_Group_setting(ctx, field) - case "users": - return ec.fieldContext_Group_users(ctx, field) - case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) - case "files": - return ec.fieldContext_Group_files(ctx, field) - case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) - case "members": - return ec.fieldContext_Group_members(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, errors.New("field of type ID does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_parent(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_parent(ctx, field) +func (ec *executionContext) _OrgSubscriptionEdge_node(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionEdge) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionEdge_node(ctx, field) if err != nil { return graphql.Null } @@ -173137,7 +174989,7 @@ func (ec *executionContext) _Organization_parent(ctx context.Context, field grap }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Parent(ctx) + return obj.Node, nil }) if err != nil { ec.Error(ctx, err) @@ -173146,146 +174998,64 @@ func (ec *executionContext) _Organization_parent(ctx context.Context, field grap if resTmp == nil { return graphql.Null } - res := resTmp.(*generated.Organization) + res := resTmp.(*generated.OrgSubscription) fc.Result = res - return ec.marshalOOrganization2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganization(ctx, field.Selections, res) + return ec.marshalOOrgSubscription2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscription(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_parent(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionEdge", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "id": - return ec.fieldContext_Organization_id(ctx, field) + return ec.fieldContext_OrgSubscription_id(ctx, field) case "createdAt": - return ec.fieldContext_Organization_createdAt(ctx, field) + return ec.fieldContext_OrgSubscription_createdAt(ctx, field) case "updatedAt": - return ec.fieldContext_Organization_updatedAt(ctx, field) + return ec.fieldContext_OrgSubscription_updatedAt(ctx, field) case "createdBy": - return ec.fieldContext_Organization_createdBy(ctx, field) + return ec.fieldContext_OrgSubscription_createdBy(ctx, field) case "updatedBy": - return ec.fieldContext_Organization_updatedBy(ctx, field) + return ec.fieldContext_OrgSubscription_updatedBy(ctx, field) case "tags": - return ec.fieldContext_Organization_tags(ctx, field) + return ec.fieldContext_OrgSubscription_tags(ctx, field) case "deletedAt": - return ec.fieldContext_Organization_deletedAt(ctx, field) + return ec.fieldContext_OrgSubscription_deletedAt(ctx, field) case "deletedBy": - return ec.fieldContext_Organization_deletedBy(ctx, field) - case "name": - return ec.fieldContext_Organization_name(ctx, field) - case "displayName": - return ec.fieldContext_Organization_displayName(ctx, field) - case "description": - return ec.fieldContext_Organization_description(ctx, field) - case "personalOrg": - return ec.fieldContext_Organization_personalOrg(ctx, field) - case "avatarRemoteURL": - return ec.fieldContext_Organization_avatarRemoteURL(ctx, field) - case "dedicatedDb": - return ec.fieldContext_Organization_dedicatedDb(ctx, field) - case "controlCreators": - return ec.fieldContext_Organization_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Organization_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Organization_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Organization_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Organization_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Organization_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Organization_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Organization_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Organization_templateCreators(ctx, field) - case "parent": - return ec.fieldContext_Organization_parent(ctx, field) - case "children": - return ec.fieldContext_Organization_children(ctx, field) - case "groups": - return ec.fieldContext_Organization_groups(ctx, field) - case "templates": - return ec.fieldContext_Organization_templates(ctx, field) - case "integrations": - return ec.fieldContext_Organization_integrations(ctx, field) - case "setting": - return ec.fieldContext_Organization_setting(ctx, field) - case "documentdata": - return ec.fieldContext_Organization_documentdata(ctx, field) - case "entitlements": - return ec.fieldContext_Organization_entitlements(ctx, field) - case "organizationEntitlement": - return ec.fieldContext_Organization_organizationEntitlement(ctx, field) - case "personalAccessTokens": - return ec.fieldContext_Organization_personalAccessTokens(ctx, field) - case "apiTokens": - return ec.fieldContext_Organization_apiTokens(ctx, field) - case "oauthprovider": - return ec.fieldContext_Organization_oauthprovider(ctx, field) - case "users": - return ec.fieldContext_Organization_users(ctx, field) - case "invites": - return ec.fieldContext_Organization_invites(ctx, field) - case "subscribers": - return ec.fieldContext_Organization_subscribers(ctx, field) - case "webhooks": - return ec.fieldContext_Organization_webhooks(ctx, field) - case "events": - return ec.fieldContext_Organization_events(ctx, field) - case "secrets": - return ec.fieldContext_Organization_secrets(ctx, field) + return ec.fieldContext_OrgSubscription_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_OrgSubscription_ownerID(ctx, field) + case "stripeSubscriptionID": + return ec.fieldContext_OrgSubscription_stripeSubscriptionID(ctx, field) + case "productTier": + return ec.fieldContext_OrgSubscription_productTier(ctx, field) + case "stripeProductTierID": + return ec.fieldContext_OrgSubscription_stripeProductTierID(ctx, field) + case "stripeSubscriptionStatus": + return ec.fieldContext_OrgSubscription_stripeSubscriptionStatus(ctx, field) + case "active": + return ec.fieldContext_OrgSubscription_active(ctx, field) + case "stripeCustomerID": + return ec.fieldContext_OrgSubscription_stripeCustomerID(ctx, field) + case "expiresAt": + return ec.fieldContext_OrgSubscription_expiresAt(ctx, field) case "features": - return ec.fieldContext_Organization_features(ctx, field) - case "files": - return ec.fieldContext_Organization_files(ctx, field) - case "entitlementplans": - return ec.fieldContext_Organization_entitlementplans(ctx, field) - case "entitlementplanfeatures": - return ec.fieldContext_Organization_entitlementplanfeatures(ctx, field) - case "entities": - return ec.fieldContext_Organization_entities(ctx, field) - case "entitytypes": - return ec.fieldContext_Organization_entitytypes(ctx, field) - case "contacts": - return ec.fieldContext_Organization_contacts(ctx, field) - case "notes": - return ec.fieldContext_Organization_notes(ctx, field) - case "tasks": - return ec.fieldContext_Organization_tasks(ctx, field) - case "programs": - return ec.fieldContext_Organization_programs(ctx, field) - case "procedures": - return ec.fieldContext_Organization_procedures(ctx, field) - case "internalpolicies": - return ec.fieldContext_Organization_internalpolicies(ctx, field) - case "risks": - return ec.fieldContext_Organization_risks(ctx, field) - case "controlobjectives": - return ec.fieldContext_Organization_controlobjectives(ctx, field) - case "narratives": - return ec.fieldContext_Organization_narratives(ctx, field) - case "controls": - return ec.fieldContext_Organization_controls(ctx, field) - case "subcontrols": - return ec.fieldContext_Organization_subcontrols(ctx, field) - case "members": - return ec.fieldContext_Organization_members(ctx, field) + return ec.fieldContext_OrgSubscription_features(ctx, field) + case "owner": + return ec.fieldContext_OrgSubscription_owner(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name) + return nil, fmt.Errorf("no field named %q was found under type OrgSubscription", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_children(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_children(ctx, field) +func (ec *executionContext) _OrgSubscriptionEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionEdge) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionEdge_cursor(ctx, field) if err != nil { return graphql.Null } @@ -173298,7 +175068,7 @@ func (ec *executionContext) _Organization_children(ctx context.Context, field gr }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Children(ctx, fc.Args["after"].(*entgql.Cursor[string]), fc.Args["first"].(*int), fc.Args["before"].(*entgql.Cursor[string]), fc.Args["last"].(*int), fc.Args["orderBy"].(*generated.OrganizationOrder), fc.Args["where"].(*generated.OrganizationWhereInput)) + return obj.Cursor, nil }) if err != nil { ec.Error(ctx, err) @@ -173310,45 +175080,114 @@ func (ec *executionContext) _Organization_children(ctx context.Context, field gr } return graphql.Null } - res := resTmp.(*generated.OrganizationConnection) + res := resTmp.(entgql.Cursor[string]) fc.Result = res - return ec.marshalNOrganizationConnection2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationConnection(ctx, field.Selections, res) + return ec.marshalNCursor2entgoᚗioᚋcontribᚋentgqlᚐCursor(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_children(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionEdge", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "edges": - return ec.fieldContext_OrganizationConnection_edges(ctx, field) - case "pageInfo": - return ec.fieldContext_OrganizationConnection_pageInfo(ctx, field) - case "totalCount": - return ec.fieldContext_OrganizationConnection_totalCount(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type OrganizationConnection", field.Name) + return nil, errors.New("field of type Cursor does not have child fields") }, } + return fc, nil +} + +func (ec *executionContext) _OrgSubscriptionHistory_id(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_id(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) defer func() { if r := recover(); r != nil { - err = ec.Recover(ctx, r) - ec.Error(ctx, err) + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null } }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNID2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "OrgSubscriptionHistory", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _OrgSubscriptionHistory_historyTime(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_historyTime(ctx, field) + if err != nil { + return graphql.Null + } ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Organization_children_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.HistoryTime, nil + }) + if err != nil { ec.Error(ctx, err) - return fc, err + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(time.Time) + fc.Result = res + return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_historyTime(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "OrgSubscriptionHistory", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, } return fc, nil } -func (ec *executionContext) _Organization_groups(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_groups(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_ref(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_ref(ctx, field) if err != nil { return graphql.Null } @@ -173361,7 +175200,7 @@ func (ec *executionContext) _Organization_groups(ctx context.Context, field grap }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Groups(ctx) + return obj.Ref, nil }) if err != nil { ec.Error(ctx, err) @@ -173370,128 +175209,26 @@ func (ec *executionContext) _Organization_groups(ctx context.Context, field grap if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Group) + res := resTmp.(string) fc.Result = res - return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_groups(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_ref(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Group_id(ctx, field) - case "createdAt": - return ec.fieldContext_Group_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Group_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Group_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Group_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Group_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Group_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Group_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Group_ownerID(ctx, field) - case "name": - return ec.fieldContext_Group_name(ctx, field) - case "description": - return ec.fieldContext_Group_description(ctx, field) - case "gravatarLogoURL": - return ec.fieldContext_Group_gravatarLogoURL(ctx, field) - case "logoURL": - return ec.fieldContext_Group_logoURL(ctx, field) - case "displayName": - return ec.fieldContext_Group_displayName(ctx, field) - case "owner": - return ec.fieldContext_Group_owner(ctx, field) - case "controlCreators": - return ec.fieldContext_Group_controlCreators(ctx, field) - case "controlObjectiveCreators": - return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) - case "groupCreators": - return ec.fieldContext_Group_groupCreators(ctx, field) - case "internalPolicyCreators": - return ec.fieldContext_Group_internalPolicyCreators(ctx, field) - case "narrativeCreators": - return ec.fieldContext_Group_narrativeCreators(ctx, field) - case "procedureCreators": - return ec.fieldContext_Group_procedureCreators(ctx, field) - case "programCreators": - return ec.fieldContext_Group_programCreators(ctx, field) - case "riskCreators": - return ec.fieldContext_Group_riskCreators(ctx, field) - case "templateCreators": - return ec.fieldContext_Group_templateCreators(ctx, field) - case "procedureEditors": - return ec.fieldContext_Group_procedureEditors(ctx, field) - case "procedureBlockedGroups": - return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) - case "internalpolicyEditors": - return ec.fieldContext_Group_internalpolicyEditors(ctx, field) - case "internalpolicyBlockedGroups": - return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) - case "programEditors": - return ec.fieldContext_Group_programEditors(ctx, field) - case "programBlockedGroups": - return ec.fieldContext_Group_programBlockedGroups(ctx, field) - case "programViewers": - return ec.fieldContext_Group_programViewers(ctx, field) - case "riskEditors": - return ec.fieldContext_Group_riskEditors(ctx, field) - case "riskBlockedGroups": - return ec.fieldContext_Group_riskBlockedGroups(ctx, field) - case "riskViewers": - return ec.fieldContext_Group_riskViewers(ctx, field) - case "controlobjectiveEditors": - return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) - case "controlobjectiveBlockedGroups": - return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) - case "controlobjectiveViewers": - return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) - case "controlEditors": - return ec.fieldContext_Group_controlEditors(ctx, field) - case "controlBlockedGroups": - return ec.fieldContext_Group_controlBlockedGroups(ctx, field) - case "controlViewers": - return ec.fieldContext_Group_controlViewers(ctx, field) - case "narrativeEditors": - return ec.fieldContext_Group_narrativeEditors(ctx, field) - case "narrativeBlockedGroups": - return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) - case "narrativeViewers": - return ec.fieldContext_Group_narrativeViewers(ctx, field) - case "setting": - return ec.fieldContext_Group_setting(ctx, field) - case "users": - return ec.fieldContext_Group_users(ctx, field) - case "events": - return ec.fieldContext_Group_events(ctx, field) - case "integrations": - return ec.fieldContext_Group_integrations(ctx, field) - case "files": - return ec.fieldContext_Group_files(ctx, field) - case "tasks": - return ec.fieldContext_Group_tasks(ctx, field) - case "members": - return ec.fieldContext_Group_members(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_templates(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_templates(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_operation(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_operation(ctx, field) if err != nil { return graphql.Null } @@ -173504,71 +175241,38 @@ func (ec *executionContext) _Organization_templates(ctx context.Context, field g }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Templates(ctx) + return obj.Operation, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.Template) + res := resTmp.(history.OpType) fc.Result = res - return ec.marshalOTemplate2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateᚄ(ctx, field.Selections, res) + return ec.marshalNOrgSubscriptionHistoryOpType2githubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_templates(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Template_id(ctx, field) - case "createdAt": - return ec.fieldContext_Template_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Template_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Template_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Template_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Template_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Template_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Template_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Template_ownerID(ctx, field) - case "name": - return ec.fieldContext_Template_name(ctx, field) - case "templateType": - return ec.fieldContext_Template_templateType(ctx, field) - case "description": - return ec.fieldContext_Template_description(ctx, field) - case "jsonconfig": - return ec.fieldContext_Template_jsonconfig(ctx, field) - case "uischema": - return ec.fieldContext_Template_uischema(ctx, field) - case "owner": - return ec.fieldContext_Template_owner(ctx, field) - case "documents": - return ec.fieldContext_Template_documents(ctx, field) - case "files": - return ec.fieldContext_Template_files(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) + return nil, errors.New("field of type OrgSubscriptionHistoryOpType does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_integrations(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_integrations(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_createdAt(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_createdAt(ctx, field) if err != nil { return graphql.Null } @@ -173581,7 +175285,7 @@ func (ec *executionContext) _Organization_integrations(ctx context.Context, fiel }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Integrations(ctx) + return obj.CreatedAt, nil }) if err != nil { ec.Error(ctx, err) @@ -173590,62 +175294,26 @@ func (ec *executionContext) _Organization_integrations(ctx context.Context, fiel if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Integration) + res := resTmp.(time.Time) fc.Result = res - return ec.marshalOIntegration2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationᚄ(ctx, field.Selections, res) + return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_integrations(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Integration_id(ctx, field) - case "createdAt": - return ec.fieldContext_Integration_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Integration_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Integration_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Integration_updatedBy(ctx, field) - case "tags": - return ec.fieldContext_Integration_tags(ctx, field) - case "deletedAt": - return ec.fieldContext_Integration_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Integration_deletedBy(ctx, field) - case "ownerID": - return ec.fieldContext_Integration_ownerID(ctx, field) - case "name": - return ec.fieldContext_Integration_name(ctx, field) - case "description": - return ec.fieldContext_Integration_description(ctx, field) - case "kind": - return ec.fieldContext_Integration_kind(ctx, field) - case "owner": - return ec.fieldContext_Integration_owner(ctx, field) - case "secrets": - return ec.fieldContext_Integration_secrets(ctx, field) - case "oauth2tokens": - return ec.fieldContext_Integration_oauth2tokens(ctx, field) - case "events": - return ec.fieldContext_Integration_events(ctx, field) - case "webhooks": - return ec.fieldContext_Integration_webhooks(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Integration", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_setting(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_setting(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_updatedAt(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_updatedAt(ctx, field) if err != nil { return graphql.Null } @@ -173658,7 +175326,7 @@ func (ec *executionContext) _Organization_setting(ctx context.Context, field gra }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Setting(ctx) + return obj.UpdatedAt, nil }) if err != nil { ec.Error(ctx, err) @@ -173667,66 +175335,26 @@ func (ec *executionContext) _Organization_setting(ctx context.Context, field gra if resTmp == nil { return graphql.Null } - res := resTmp.(*generated.OrganizationSetting) + res := resTmp.(time.Time) fc.Result = res - return ec.marshalOOrganizationSetting2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationSetting(ctx, field.Selections, res) + return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_setting(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_OrganizationSetting_id(ctx, field) - case "createdAt": - return ec.fieldContext_OrganizationSetting_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_OrganizationSetting_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_OrganizationSetting_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_OrganizationSetting_updatedBy(ctx, field) - case "tags": - return ec.fieldContext_OrganizationSetting_tags(ctx, field) - case "deletedAt": - return ec.fieldContext_OrganizationSetting_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_OrganizationSetting_deletedBy(ctx, field) - case "domains": - return ec.fieldContext_OrganizationSetting_domains(ctx, field) - case "billingContact": - return ec.fieldContext_OrganizationSetting_billingContact(ctx, field) - case "billingEmail": - return ec.fieldContext_OrganizationSetting_billingEmail(ctx, field) - case "billingPhone": - return ec.fieldContext_OrganizationSetting_billingPhone(ctx, field) - case "billingAddress": - return ec.fieldContext_OrganizationSetting_billingAddress(ctx, field) - case "taxIdentifier": - return ec.fieldContext_OrganizationSetting_taxIdentifier(ctx, field) - case "geoLocation": - return ec.fieldContext_OrganizationSetting_geoLocation(ctx, field) - case "organizationID": - return ec.fieldContext_OrganizationSetting_organizationID(ctx, field) - case "stripeID": - return ec.fieldContext_OrganizationSetting_stripeID(ctx, field) - case "organization": - return ec.fieldContext_OrganizationSetting_organization(ctx, field) - case "files": - return ec.fieldContext_OrganizationSetting_files(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type OrganizationSetting", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_documentdata(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_documentdata(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_createdBy(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_createdBy(ctx, field) if err != nil { return graphql.Null } @@ -173739,7 +175367,7 @@ func (ec *executionContext) _Organization_documentdata(ctx context.Context, fiel }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Documentdata(ctx) + return obj.CreatedBy, nil }) if err != nil { ec.Error(ctx, err) @@ -173748,58 +175376,26 @@ func (ec *executionContext) _Organization_documentdata(ctx context.Context, fiel if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.DocumentData) + res := resTmp.(string) fc.Result = res - return ec.marshalODocumentData2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐDocumentDataᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_documentdata(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_createdBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_DocumentData_id(ctx, field) - case "createdAt": - return ec.fieldContext_DocumentData_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_DocumentData_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_DocumentData_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_DocumentData_updatedBy(ctx, field) - case "tags": - return ec.fieldContext_DocumentData_tags(ctx, field) - case "deletedAt": - return ec.fieldContext_DocumentData_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_DocumentData_deletedBy(ctx, field) - case "ownerID": - return ec.fieldContext_DocumentData_ownerID(ctx, field) - case "templateID": - return ec.fieldContext_DocumentData_templateID(ctx, field) - case "data": - return ec.fieldContext_DocumentData_data(ctx, field) - case "owner": - return ec.fieldContext_DocumentData_owner(ctx, field) - case "template": - return ec.fieldContext_DocumentData_template(ctx, field) - case "entity": - return ec.fieldContext_DocumentData_entity(ctx, field) - case "files": - return ec.fieldContext_DocumentData_files(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type DocumentData", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_entitlements(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_entitlements(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_updatedBy(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_updatedBy(ctx, field) if err != nil { return graphql.Null } @@ -173812,7 +175408,7 @@ func (ec *executionContext) _Organization_entitlements(ctx context.Context, fiel }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Entitlements(ctx) + return obj.UpdatedBy, nil }) if err != nil { ec.Error(ctx, err) @@ -173821,74 +175417,26 @@ func (ec *executionContext) _Organization_entitlements(ctx context.Context, fiel if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Entitlement) + res := resTmp.(string) fc.Result = res - return ec.marshalOEntitlement2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_entitlements(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_updatedBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Entitlement_id(ctx, field) - case "createdAt": - return ec.fieldContext_Entitlement_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Entitlement_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Entitlement_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Entitlement_updatedBy(ctx, field) - case "tags": - return ec.fieldContext_Entitlement_tags(ctx, field) - case "deletedAt": - return ec.fieldContext_Entitlement_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Entitlement_deletedBy(ctx, field) - case "ownerID": - return ec.fieldContext_Entitlement_ownerID(ctx, field) - case "planID": - return ec.fieldContext_Entitlement_planID(ctx, field) - case "organizationID": - return ec.fieldContext_Entitlement_organizationID(ctx, field) - case "externalCustomerID": - return ec.fieldContext_Entitlement_externalCustomerID(ctx, field) - case "externalSubscriptionID": - return ec.fieldContext_Entitlement_externalSubscriptionID(ctx, field) - case "expires": - return ec.fieldContext_Entitlement_expires(ctx, field) - case "expiresAt": - return ec.fieldContext_Entitlement_expiresAt(ctx, field) - case "cancelled": - return ec.fieldContext_Entitlement_cancelled(ctx, field) - case "cancelledDate": - return ec.fieldContext_Entitlement_cancelledDate(ctx, field) - case "billStarting": - return ec.fieldContext_Entitlement_billStarting(ctx, field) - case "active": - return ec.fieldContext_Entitlement_active(ctx, field) - case "owner": - return ec.fieldContext_Entitlement_owner(ctx, field) - case "plan": - return ec.fieldContext_Entitlement_plan(ctx, field) - case "organization": - return ec.fieldContext_Entitlement_organization(ctx, field) - case "events": - return ec.fieldContext_Entitlement_events(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Entitlement", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_organizationEntitlement(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_organizationEntitlement(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_tags(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_tags(ctx, field) if err != nil { return graphql.Null } @@ -173901,7 +175449,7 @@ func (ec *executionContext) _Organization_organizationEntitlement(ctx context.Co }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.OrganizationEntitlement(ctx) + return obj.Tags, nil }) if err != nil { ec.Error(ctx, err) @@ -173910,74 +175458,26 @@ func (ec *executionContext) _Organization_organizationEntitlement(ctx context.Co if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Entitlement) + res := resTmp.([]string) fc.Result = res - return ec.marshalOEntitlement2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementᚄ(ctx, field.Selections, res) + return ec.marshalOString2ᚕstringᚄ(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_organizationEntitlement(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_tags(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Entitlement_id(ctx, field) - case "createdAt": - return ec.fieldContext_Entitlement_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Entitlement_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Entitlement_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Entitlement_updatedBy(ctx, field) - case "tags": - return ec.fieldContext_Entitlement_tags(ctx, field) - case "deletedAt": - return ec.fieldContext_Entitlement_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Entitlement_deletedBy(ctx, field) - case "ownerID": - return ec.fieldContext_Entitlement_ownerID(ctx, field) - case "planID": - return ec.fieldContext_Entitlement_planID(ctx, field) - case "organizationID": - return ec.fieldContext_Entitlement_organizationID(ctx, field) - case "externalCustomerID": - return ec.fieldContext_Entitlement_externalCustomerID(ctx, field) - case "externalSubscriptionID": - return ec.fieldContext_Entitlement_externalSubscriptionID(ctx, field) - case "expires": - return ec.fieldContext_Entitlement_expires(ctx, field) - case "expiresAt": - return ec.fieldContext_Entitlement_expiresAt(ctx, field) - case "cancelled": - return ec.fieldContext_Entitlement_cancelled(ctx, field) - case "cancelledDate": - return ec.fieldContext_Entitlement_cancelledDate(ctx, field) - case "billStarting": - return ec.fieldContext_Entitlement_billStarting(ctx, field) - case "active": - return ec.fieldContext_Entitlement_active(ctx, field) - case "owner": - return ec.fieldContext_Entitlement_owner(ctx, field) - case "plan": - return ec.fieldContext_Entitlement_plan(ctx, field) - case "organization": - return ec.fieldContext_Entitlement_organization(ctx, field) - case "events": - return ec.fieldContext_Entitlement_events(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Entitlement", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_personalAccessTokens(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_personalAccessTokens(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_deletedAt(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_deletedAt(ctx, field) if err != nil { return graphql.Null } @@ -173990,7 +175490,7 @@ func (ec *executionContext) _Organization_personalAccessTokens(ctx context.Conte }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.PersonalAccessTokens(ctx) + return obj.DeletedAt, nil }) if err != nil { ec.Error(ctx, err) @@ -173999,62 +175499,26 @@ func (ec *executionContext) _Organization_personalAccessTokens(ctx context.Conte if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.PersonalAccessToken) + res := resTmp.(time.Time) fc.Result = res - return ec.marshalOPersonalAccessToken2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐPersonalAccessTokenᚄ(ctx, field.Selections, res) + return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_personalAccessTokens(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_deletedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_PersonalAccessToken_id(ctx, field) - case "createdAt": - return ec.fieldContext_PersonalAccessToken_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_PersonalAccessToken_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_PersonalAccessToken_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_PersonalAccessToken_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_PersonalAccessToken_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_PersonalAccessToken_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_PersonalAccessToken_tags(ctx, field) - case "name": - return ec.fieldContext_PersonalAccessToken_name(ctx, field) - case "token": - return ec.fieldContext_PersonalAccessToken_token(ctx, field) - case "expiresAt": - return ec.fieldContext_PersonalAccessToken_expiresAt(ctx, field) - case "description": - return ec.fieldContext_PersonalAccessToken_description(ctx, field) - case "scopes": - return ec.fieldContext_PersonalAccessToken_scopes(ctx, field) - case "lastUsedAt": - return ec.fieldContext_PersonalAccessToken_lastUsedAt(ctx, field) - case "owner": - return ec.fieldContext_PersonalAccessToken_owner(ctx, field) - case "organizations": - return ec.fieldContext_PersonalAccessToken_organizations(ctx, field) - case "events": - return ec.fieldContext_PersonalAccessToken_events(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type PersonalAccessToken", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_apiTokens(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_apiTokens(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_deletedBy(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_deletedBy(ctx, field) if err != nil { return graphql.Null } @@ -174067,7 +175531,7 @@ func (ec *executionContext) _Organization_apiTokens(ctx context.Context, field g }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.APITokens(ctx) + return obj.DeletedBy, nil }) if err != nil { ec.Error(ctx, err) @@ -174076,60 +175540,26 @@ func (ec *executionContext) _Organization_apiTokens(ctx context.Context, field g if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.APIToken) + res := resTmp.(string) fc.Result = res - return ec.marshalOAPIToken2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐAPITokenᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_apiTokens(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_deletedBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_APIToken_id(ctx, field) - case "createdAt": - return ec.fieldContext_APIToken_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_APIToken_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_APIToken_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_APIToken_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_APIToken_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_APIToken_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_APIToken_tags(ctx, field) - case "ownerID": - return ec.fieldContext_APIToken_ownerID(ctx, field) - case "name": - return ec.fieldContext_APIToken_name(ctx, field) - case "token": - return ec.fieldContext_APIToken_token(ctx, field) - case "expiresAt": - return ec.fieldContext_APIToken_expiresAt(ctx, field) - case "description": - return ec.fieldContext_APIToken_description(ctx, field) - case "scopes": - return ec.fieldContext_APIToken_scopes(ctx, field) - case "lastUsedAt": - return ec.fieldContext_APIToken_lastUsedAt(ctx, field) - case "owner": - return ec.fieldContext_APIToken_owner(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type APIToken", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_oauthprovider(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_oauthprovider(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_ownerID(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_ownerID(ctx, field) if err != nil { return graphql.Null } @@ -174142,7 +175572,7 @@ func (ec *executionContext) _Organization_oauthprovider(ctx context.Context, fie }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Oauthprovider(ctx) + return obj.OwnerID, nil }) if err != nil { ec.Error(ctx, err) @@ -174151,66 +175581,26 @@ func (ec *executionContext) _Organization_oauthprovider(ctx context.Context, fie if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.OauthProvider) + res := resTmp.(string) fc.Result = res - return ec.marshalOOauthProvider2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_oauthprovider(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_ownerID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_OauthProvider_id(ctx, field) - case "createdAt": - return ec.fieldContext_OauthProvider_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_OauthProvider_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_OauthProvider_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_OauthProvider_updatedBy(ctx, field) - case "tags": - return ec.fieldContext_OauthProvider_tags(ctx, field) - case "deletedAt": - return ec.fieldContext_OauthProvider_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_OauthProvider_deletedBy(ctx, field) - case "ownerID": - return ec.fieldContext_OauthProvider_ownerID(ctx, field) - case "name": - return ec.fieldContext_OauthProvider_name(ctx, field) - case "clientID": - return ec.fieldContext_OauthProvider_clientID(ctx, field) - case "clientSecret": - return ec.fieldContext_OauthProvider_clientSecret(ctx, field) - case "redirectURL": - return ec.fieldContext_OauthProvider_redirectURL(ctx, field) - case "scopes": - return ec.fieldContext_OauthProvider_scopes(ctx, field) - case "authURL": - return ec.fieldContext_OauthProvider_authURL(ctx, field) - case "tokenURL": - return ec.fieldContext_OauthProvider_tokenURL(ctx, field) - case "authStyle": - return ec.fieldContext_OauthProvider_authStyle(ctx, field) - case "infoURL": - return ec.fieldContext_OauthProvider_infoURL(ctx, field) - case "owner": - return ec.fieldContext_OauthProvider_owner(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type OauthProvider", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_users(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_users(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_stripeSubscriptionID(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_stripeSubscriptionID(ctx, field) if err != nil { return graphql.Null } @@ -174223,7 +175613,7 @@ func (ec *executionContext) _Organization_users(ctx context.Context, field graph }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Users(ctx) + return obj.StripeSubscriptionID, nil }) if err != nil { ec.Error(ctx, err) @@ -174232,100 +175622,26 @@ func (ec *executionContext) _Organization_users(ctx context.Context, field graph if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.User) + res := resTmp.(string) fc.Result = res - return ec.marshalOUser2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_users(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_stripeSubscriptionID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_User_id(ctx, field) - case "createdAt": - return ec.fieldContext_User_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_User_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_User_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_User_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_User_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_User_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_User_tags(ctx, field) - case "email": - return ec.fieldContext_User_email(ctx, field) - case "firstName": - return ec.fieldContext_User_firstName(ctx, field) - case "lastName": - return ec.fieldContext_User_lastName(ctx, field) - case "displayName": - return ec.fieldContext_User_displayName(ctx, field) - case "avatarRemoteURL": - return ec.fieldContext_User_avatarRemoteURL(ctx, field) - case "avatarLocalFile": - return ec.fieldContext_User_avatarLocalFile(ctx, field) - case "avatarLocalFileID": - return ec.fieldContext_User_avatarLocalFileID(ctx, field) - case "avatarUpdatedAt": - return ec.fieldContext_User_avatarUpdatedAt(ctx, field) - case "lastSeen": - return ec.fieldContext_User_lastSeen(ctx, field) - case "sub": - return ec.fieldContext_User_sub(ctx, field) - case "authProvider": - return ec.fieldContext_User_authProvider(ctx, field) - case "role": - return ec.fieldContext_User_role(ctx, field) - case "personalAccessTokens": - return ec.fieldContext_User_personalAccessTokens(ctx, field) - case "tfaSettings": - return ec.fieldContext_User_tfaSettings(ctx, field) - case "setting": - return ec.fieldContext_User_setting(ctx, field) - case "groups": - return ec.fieldContext_User_groups(ctx, field) - case "organizations": - return ec.fieldContext_User_organizations(ctx, field) - case "files": - return ec.fieldContext_User_files(ctx, field) - case "file": - return ec.fieldContext_User_file(ctx, field) - case "events": - return ec.fieldContext_User_events(ctx, field) - case "actionplans": - return ec.fieldContext_User_actionplans(ctx, field) - case "subcontrols": - return ec.fieldContext_User_subcontrols(ctx, field) - case "assignerTasks": - return ec.fieldContext_User_assignerTasks(ctx, field) - case "assigneeTasks": - return ec.fieldContext_User_assigneeTasks(ctx, field) - case "programs": - return ec.fieldContext_User_programs(ctx, field) - case "groupMemberships": - return ec.fieldContext_User_groupMemberships(ctx, field) - case "orgMemberships": - return ec.fieldContext_User_orgMemberships(ctx, field) - case "programMemberships": - return ec.fieldContext_User_programMemberships(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type User", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_invites(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_invites(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_productTier(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_productTier(ctx, field) if err != nil { return graphql.Null } @@ -174338,7 +175654,7 @@ func (ec *executionContext) _Organization_invites(ctx context.Context, field gra }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Invites(ctx) + return obj.ProductTier, nil }) if err != nil { ec.Error(ctx, err) @@ -174347,60 +175663,26 @@ func (ec *executionContext) _Organization_invites(ctx context.Context, field gra if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Invite) + res := resTmp.(string) fc.Result = res - return ec.marshalOInvite2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_invites(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_productTier(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Invite_id(ctx, field) - case "createdAt": - return ec.fieldContext_Invite_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Invite_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Invite_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Invite_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Invite_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Invite_deletedBy(ctx, field) - case "ownerID": - return ec.fieldContext_Invite_ownerID(ctx, field) - case "expires": - return ec.fieldContext_Invite_expires(ctx, field) - case "recipient": - return ec.fieldContext_Invite_recipient(ctx, field) - case "status": - return ec.fieldContext_Invite_status(ctx, field) - case "role": - return ec.fieldContext_Invite_role(ctx, field) - case "sendAttempts": - return ec.fieldContext_Invite_sendAttempts(ctx, field) - case "requestorID": - return ec.fieldContext_Invite_requestorID(ctx, field) - case "owner": - return ec.fieldContext_Invite_owner(ctx, field) - case "events": - return ec.fieldContext_Invite_events(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Invite", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_subscribers(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_subscribers(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_stripeProductTierID(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_stripeProductTierID(ctx, field) if err != nil { return graphql.Null } @@ -174413,7 +175695,7 @@ func (ec *executionContext) _Organization_subscribers(ctx context.Context, field }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Subscribers(ctx) + return obj.StripeProductTierID, nil }) if err != nil { ec.Error(ctx, err) @@ -174422,60 +175704,26 @@ func (ec *executionContext) _Organization_subscribers(ctx context.Context, field if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Subscriber) + res := resTmp.(string) fc.Result = res - return ec.marshalOSubscriber2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubscriberᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_subscribers(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_stripeProductTierID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Subscriber_id(ctx, field) - case "createdAt": - return ec.fieldContext_Subscriber_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Subscriber_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Subscriber_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Subscriber_updatedBy(ctx, field) - case "tags": - return ec.fieldContext_Subscriber_tags(ctx, field) - case "deletedAt": - return ec.fieldContext_Subscriber_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Subscriber_deletedBy(ctx, field) - case "ownerID": - return ec.fieldContext_Subscriber_ownerID(ctx, field) - case "email": - return ec.fieldContext_Subscriber_email(ctx, field) - case "phoneNumber": - return ec.fieldContext_Subscriber_phoneNumber(ctx, field) - case "verifiedEmail": - return ec.fieldContext_Subscriber_verifiedEmail(ctx, field) - case "verifiedPhone": - return ec.fieldContext_Subscriber_verifiedPhone(ctx, field) - case "active": - return ec.fieldContext_Subscriber_active(ctx, field) - case "owner": - return ec.fieldContext_Subscriber_owner(ctx, field) - case "events": - return ec.fieldContext_Subscriber_events(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Subscriber", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_webhooks(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_webhooks(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_stripeSubscriptionStatus(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_stripeSubscriptionStatus(ctx, field) if err != nil { return graphql.Null } @@ -174488,7 +175736,7 @@ func (ec *executionContext) _Organization_webhooks(ctx context.Context, field gr }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Webhooks(ctx) + return obj.StripeSubscriptionStatus, nil }) if err != nil { ec.Error(ctx, err) @@ -174497,66 +175745,26 @@ func (ec *executionContext) _Organization_webhooks(ctx context.Context, field gr if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Webhook) + res := resTmp.(string) fc.Result = res - return ec.marshalOWebhook2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐWebhookᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_webhooks(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_stripeSubscriptionStatus(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Webhook_id(ctx, field) - case "createdAt": - return ec.fieldContext_Webhook_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Webhook_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Webhook_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Webhook_updatedBy(ctx, field) - case "tags": - return ec.fieldContext_Webhook_tags(ctx, field) - case "deletedAt": - return ec.fieldContext_Webhook_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Webhook_deletedBy(ctx, field) - case "ownerID": - return ec.fieldContext_Webhook_ownerID(ctx, field) - case "name": - return ec.fieldContext_Webhook_name(ctx, field) - case "description": - return ec.fieldContext_Webhook_description(ctx, field) - case "destinationURL": - return ec.fieldContext_Webhook_destinationURL(ctx, field) - case "enabled": - return ec.fieldContext_Webhook_enabled(ctx, field) - case "failures": - return ec.fieldContext_Webhook_failures(ctx, field) - case "lastError": - return ec.fieldContext_Webhook_lastError(ctx, field) - case "lastResponse": - return ec.fieldContext_Webhook_lastResponse(ctx, field) - case "owner": - return ec.fieldContext_Webhook_owner(ctx, field) - case "events": - return ec.fieldContext_Webhook_events(ctx, field) - case "integrations": - return ec.fieldContext_Webhook_integrations(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Webhook", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_events(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_events(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_active(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_active(ctx, field) if err != nil { return graphql.Null } @@ -174569,91 +175777,38 @@ func (ec *executionContext) _Organization_events(ctx context.Context, field grap }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Events(ctx) + return obj.Active, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.Event) + res := resTmp.(bool) fc.Result = res - return ec.marshalOEvent2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventᚄ(ctx, field.Selections, res) + return ec.marshalNBoolean2bool(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_events(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_active(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Event_id(ctx, field) - case "createdAt": - return ec.fieldContext_Event_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Event_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Event_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Event_updatedBy(ctx, field) - case "tags": - return ec.fieldContext_Event_tags(ctx, field) - case "eventID": - return ec.fieldContext_Event_eventID(ctx, field) - case "correlationID": - return ec.fieldContext_Event_correlationID(ctx, field) - case "eventType": - return ec.fieldContext_Event_eventType(ctx, field) - case "metadata": - return ec.fieldContext_Event_metadata(ctx, field) - case "user": - return ec.fieldContext_Event_user(ctx, field) - case "group": - return ec.fieldContext_Event_group(ctx, field) - case "integration": - return ec.fieldContext_Event_integration(ctx, field) - case "organization": - return ec.fieldContext_Event_organization(ctx, field) - case "invite": - return ec.fieldContext_Event_invite(ctx, field) - case "feature": - return ec.fieldContext_Event_feature(ctx, field) - case "entitlementplan": - return ec.fieldContext_Event_entitlementplan(ctx, field) - case "entitlementplanfeature": - return ec.fieldContext_Event_entitlementplanfeature(ctx, field) - case "personalAccessToken": - return ec.fieldContext_Event_personalAccessToken(ctx, field) - case "oauth2token": - return ec.fieldContext_Event_oauth2token(ctx, field) - case "hush": - return ec.fieldContext_Event_hush(ctx, field) - case "orgmembership": - return ec.fieldContext_Event_orgmembership(ctx, field) - case "groupmembership": - return ec.fieldContext_Event_groupmembership(ctx, field) - case "entitlement": - return ec.fieldContext_Event_entitlement(ctx, field) - case "webhook": - return ec.fieldContext_Event_webhook(ctx, field) - case "subscriber": - return ec.fieldContext_Event_subscriber(ctx, field) - case "file": - return ec.fieldContext_Event_file(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Event", field.Name) + return nil, errors.New("field of type Boolean does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_secrets(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_secrets(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_stripeCustomerID(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_stripeCustomerID(ctx, field) if err != nil { return graphql.Null } @@ -174666,7 +175821,7 @@ func (ec *executionContext) _Organization_secrets(ctx context.Context, field gra }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Secrets(ctx) + return obj.StripeCustomerID, nil }) if err != nil { ec.Error(ctx, err) @@ -174675,56 +175830,26 @@ func (ec *executionContext) _Organization_secrets(ctx context.Context, field gra if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Hush) + res := resTmp.(string) fc.Result = res - return ec.marshalOHush2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushᚄ(ctx, field.Selections, res) + return ec.marshalOString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_secrets(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_stripeCustomerID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Hush_id(ctx, field) - case "createdAt": - return ec.fieldContext_Hush_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Hush_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Hush_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Hush_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Hush_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Hush_deletedBy(ctx, field) - case "name": - return ec.fieldContext_Hush_name(ctx, field) - case "description": - return ec.fieldContext_Hush_description(ctx, field) - case "kind": - return ec.fieldContext_Hush_kind(ctx, field) - case "secretName": - return ec.fieldContext_Hush_secretName(ctx, field) - case "integrations": - return ec.fieldContext_Hush_integrations(ctx, field) - case "organization": - return ec.fieldContext_Hush_organization(ctx, field) - case "events": - return ec.fieldContext_Hush_events(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Hush", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_features(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_features(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_expiresAt(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_expiresAt(ctx, field) if err != nil { return graphql.Null } @@ -174737,7 +175862,7 @@ func (ec *executionContext) _Organization_features(ctx context.Context, field gr }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Features(ctx) + return obj.ExpiresAt, nil }) if err != nil { ec.Error(ctx, err) @@ -174746,66 +175871,26 @@ func (ec *executionContext) _Organization_features(ctx context.Context, field gr if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Feature) + res := resTmp.(*time.Time) fc.Result = res - return ec.marshalOFeature2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureᚄ(ctx, field.Selections, res) + return ec.marshalOTime2ᚖtimeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_features(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_expiresAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Feature_id(ctx, field) - case "createdAt": - return ec.fieldContext_Feature_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Feature_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Feature_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Feature_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Feature_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Feature_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Feature_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Feature_ownerID(ctx, field) - case "name": - return ec.fieldContext_Feature_name(ctx, field) - case "displayName": - return ec.fieldContext_Feature_displayName(ctx, field) - case "enabled": - return ec.fieldContext_Feature_enabled(ctx, field) - case "description": - return ec.fieldContext_Feature_description(ctx, field) - case "metadata": - return ec.fieldContext_Feature_metadata(ctx, field) - case "stripeFeatureID": - return ec.fieldContext_Feature_stripeFeatureID(ctx, field) - case "owner": - return ec.fieldContext_Feature_owner(ctx, field) - case "plans": - return ec.fieldContext_Feature_plans(ctx, field) - case "events": - return ec.fieldContext_Feature_events(ctx, field) - case "features": - return ec.fieldContext_Feature_features(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Feature", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_files(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_files(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistory_features(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistory) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistory_features(ctx, field) if err != nil { return graphql.Null } @@ -174818,7 +175903,7 @@ func (ec *executionContext) _Organization_files(ctx context.Context, field graph }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Files(ctx) + return obj.Features, nil }) if err != nil { ec.Error(ctx, err) @@ -174827,92 +175912,26 @@ func (ec *executionContext) _Organization_files(ctx context.Context, field graph if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.File) + res := resTmp.([]string) fc.Result = res - return ec.marshalOFile2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileᚄ(ctx, field.Selections, res) + return ec.marshalOString2ᚕstringᚄ(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistory_features(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistory", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_File_id(ctx, field) - case "createdAt": - return ec.fieldContext_File_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_File_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_File_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_File_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_File_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_File_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_File_tags(ctx, field) - case "providedFileName": - return ec.fieldContext_File_providedFileName(ctx, field) - case "providedFileExtension": - return ec.fieldContext_File_providedFileExtension(ctx, field) - case "providedFileSize": - return ec.fieldContext_File_providedFileSize(ctx, field) - case "persistedFileSize": - return ec.fieldContext_File_persistedFileSize(ctx, field) - case "detectedMimeType": - return ec.fieldContext_File_detectedMimeType(ctx, field) - case "md5Hash": - return ec.fieldContext_File_md5Hash(ctx, field) - case "detectedContentType": - return ec.fieldContext_File_detectedContentType(ctx, field) - case "storeKey": - return ec.fieldContext_File_storeKey(ctx, field) - case "categoryType": - return ec.fieldContext_File_categoryType(ctx, field) - case "uri": - return ec.fieldContext_File_uri(ctx, field) - case "storageScheme": - return ec.fieldContext_File_storageScheme(ctx, field) - case "storageVolume": - return ec.fieldContext_File_storageVolume(ctx, field) - case "storagePath": - return ec.fieldContext_File_storagePath(ctx, field) - case "user": - return ec.fieldContext_File_user(ctx, field) - case "organization": - return ec.fieldContext_File_organization(ctx, field) - case "group": - return ec.fieldContext_File_group(ctx, field) - case "contact": - return ec.fieldContext_File_contact(ctx, field) - case "entity": - return ec.fieldContext_File_entity(ctx, field) - case "usersetting": - return ec.fieldContext_File_usersetting(ctx, field) - case "organizationsetting": - return ec.fieldContext_File_organizationsetting(ctx, field) - case "template": - return ec.fieldContext_File_template(ctx, field) - case "documentdata": - return ec.fieldContext_File_documentdata(ctx, field) - case "events": - return ec.fieldContext_File_events(ctx, field) - case "program": - return ec.fieldContext_File_program(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type File", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_entitlementplans(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_entitlementplans(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistoryConnection_edges(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistoryConnection) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistoryConnection_edges(ctx, field) if err != nil { return graphql.Null } @@ -174925,7 +175944,7 @@ func (ec *executionContext) _Organization_entitlementplans(ctx context.Context, }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Entitlementplans(ctx) + return obj.Edges, nil }) if err != nil { ec.Error(ctx, err) @@ -174934,70 +175953,32 @@ func (ec *executionContext) _Organization_entitlementplans(ctx context.Context, if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.EntitlementPlan) + res := resTmp.([]*generated.OrgSubscriptionHistoryEdge) fc.Result = res - return ec.marshalOEntitlementPlan2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanᚄ(ctx, field.Selections, res) + return ec.marshalOOrgSubscriptionHistoryEdge2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryEdge(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_entitlementplans(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistoryConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistoryConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "id": - return ec.fieldContext_EntitlementPlan_id(ctx, field) - case "createdAt": - return ec.fieldContext_EntitlementPlan_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_EntitlementPlan_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_EntitlementPlan_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_EntitlementPlan_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_EntitlementPlan_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_EntitlementPlan_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_EntitlementPlan_tags(ctx, field) - case "ownerID": - return ec.fieldContext_EntitlementPlan_ownerID(ctx, field) - case "displayName": - return ec.fieldContext_EntitlementPlan_displayName(ctx, field) - case "name": - return ec.fieldContext_EntitlementPlan_name(ctx, field) - case "description": - return ec.fieldContext_EntitlementPlan_description(ctx, field) - case "version": - return ec.fieldContext_EntitlementPlan_version(ctx, field) - case "metadata": - return ec.fieldContext_EntitlementPlan_metadata(ctx, field) - case "stripeProductID": - return ec.fieldContext_EntitlementPlan_stripeProductID(ctx, field) - case "stripePriceID": - return ec.fieldContext_EntitlementPlan_stripePriceID(ctx, field) - case "owner": - return ec.fieldContext_EntitlementPlan_owner(ctx, field) - case "entitlements": - return ec.fieldContext_EntitlementPlan_entitlements(ctx, field) - case "baseFeatures": - return ec.fieldContext_EntitlementPlan_baseFeatures(ctx, field) - case "events": - return ec.fieldContext_EntitlementPlan_events(ctx, field) - case "features": - return ec.fieldContext_EntitlementPlan_features(ctx, field) + case "node": + return ec.fieldContext_OrgSubscriptionHistoryEdge_node(ctx, field) + case "cursor": + return ec.fieldContext_OrgSubscriptionHistoryEdge_cursor(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type EntitlementPlan", field.Name) + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionHistoryEdge", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_entitlementplanfeatures(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_entitlementplanfeatures(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistoryConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistoryConnection) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistoryConnection_pageInfo(ctx, field) if err != nil { return graphql.Null } @@ -175010,73 +175991,48 @@ func (ec *executionContext) _Organization_entitlementplanfeatures(ctx context.Co }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Entitlementplanfeatures(ctx) + return obj.PageInfo, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.EntitlementPlanFeature) + res := resTmp.(entgql.PageInfo[string]) fc.Result = res - return ec.marshalOEntitlementPlanFeature2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanFeatureᚄ(ctx, field.Selections, res) + return ec.marshalNPageInfo2entgoᚗioᚋcontribᚋentgqlᚐPageInfo(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_entitlementplanfeatures(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistoryConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistoryConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "id": - return ec.fieldContext_EntitlementPlanFeature_id(ctx, field) - case "createdAt": - return ec.fieldContext_EntitlementPlanFeature_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_EntitlementPlanFeature_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_EntitlementPlanFeature_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_EntitlementPlanFeature_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_EntitlementPlanFeature_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_EntitlementPlanFeature_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_EntitlementPlanFeature_tags(ctx, field) - case "ownerID": - return ec.fieldContext_EntitlementPlanFeature_ownerID(ctx, field) - case "metadata": - return ec.fieldContext_EntitlementPlanFeature_metadata(ctx, field) - case "planID": - return ec.fieldContext_EntitlementPlanFeature_planID(ctx, field) - case "stripeProductID": - return ec.fieldContext_EntitlementPlanFeature_stripeProductID(ctx, field) - case "featureID": - return ec.fieldContext_EntitlementPlanFeature_featureID(ctx, field) - case "stripeFeatureID": - return ec.fieldContext_EntitlementPlanFeature_stripeFeatureID(ctx, field) - case "owner": - return ec.fieldContext_EntitlementPlanFeature_owner(ctx, field) - case "plan": - return ec.fieldContext_EntitlementPlanFeature_plan(ctx, field) - case "feature": - return ec.fieldContext_EntitlementPlanFeature_feature(ctx, field) - case "events": - return ec.fieldContext_EntitlementPlanFeature_events(ctx, field) + case "hasNextPage": + return ec.fieldContext_PageInfo_hasNextPage(ctx, field) + case "hasPreviousPage": + return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field) + case "startCursor": + return ec.fieldContext_PageInfo_startCursor(ctx, field) + case "endCursor": + return ec.fieldContext_PageInfo_endCursor(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type EntitlementPlanFeature", field.Name) + return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_entities(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_entities(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistoryConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistoryConnection) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistoryConnection_totalCount(ctx, field) if err != nil { return graphql.Null } @@ -175089,79 +176045,38 @@ func (ec *executionContext) _Organization_entities(ctx context.Context, field gr }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Entities(ctx) + return obj.TotalCount, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.Entity) + res := resTmp.(int) fc.Result = res - return ec.marshalOEntity2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityᚄ(ctx, field.Selections, res) + return ec.marshalNInt2int(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_entities(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistoryConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistoryConnection", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Entity_id(ctx, field) - case "createdAt": - return ec.fieldContext_Entity_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Entity_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Entity_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Entity_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Entity_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Entity_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Entity_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Entity_ownerID(ctx, field) - case "name": - return ec.fieldContext_Entity_name(ctx, field) - case "displayName": - return ec.fieldContext_Entity_displayName(ctx, field) - case "description": - return ec.fieldContext_Entity_description(ctx, field) - case "domains": - return ec.fieldContext_Entity_domains(ctx, field) - case "entityTypeID": - return ec.fieldContext_Entity_entityTypeID(ctx, field) - case "status": - return ec.fieldContext_Entity_status(ctx, field) - case "owner": - return ec.fieldContext_Entity_owner(ctx, field) - case "contacts": - return ec.fieldContext_Entity_contacts(ctx, field) - case "documents": - return ec.fieldContext_Entity_documents(ctx, field) - case "notes": - return ec.fieldContext_Entity_notes(ctx, field) - case "files": - return ec.fieldContext_Entity_files(ctx, field) - case "entityType": - return ec.fieldContext_Entity_entityType(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Entity", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_entitytypes(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_entitytypes(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistoryEdge_node(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistoryEdge) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistoryEdge_node(ctx, field) if err != nil { return graphql.Null } @@ -175174,7 +176089,7 @@ func (ec *executionContext) _Organization_entitytypes(ctx context.Context, field }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Entitytypes(ctx) + return obj.Node, nil }) if err != nil { ec.Error(ctx, err) @@ -175183,52 +176098,68 @@ func (ec *executionContext) _Organization_entitytypes(ctx context.Context, field if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.EntityType) + res := resTmp.(*generated.OrgSubscriptionHistory) fc.Result = res - return ec.marshalOEntityType2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityTypeᚄ(ctx, field.Selections, res) + return ec.marshalOOrgSubscriptionHistory2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistory(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_entitytypes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistoryEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistoryEdge", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "id": - return ec.fieldContext_EntityType_id(ctx, field) + return ec.fieldContext_OrgSubscriptionHistory_id(ctx, field) + case "historyTime": + return ec.fieldContext_OrgSubscriptionHistory_historyTime(ctx, field) + case "ref": + return ec.fieldContext_OrgSubscriptionHistory_ref(ctx, field) + case "operation": + return ec.fieldContext_OrgSubscriptionHistory_operation(ctx, field) case "createdAt": - return ec.fieldContext_EntityType_createdAt(ctx, field) + return ec.fieldContext_OrgSubscriptionHistory_createdAt(ctx, field) case "updatedAt": - return ec.fieldContext_EntityType_updatedAt(ctx, field) + return ec.fieldContext_OrgSubscriptionHistory_updatedAt(ctx, field) case "createdBy": - return ec.fieldContext_EntityType_createdBy(ctx, field) + return ec.fieldContext_OrgSubscriptionHistory_createdBy(ctx, field) case "updatedBy": - return ec.fieldContext_EntityType_updatedBy(ctx, field) + return ec.fieldContext_OrgSubscriptionHistory_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_OrgSubscriptionHistory_tags(ctx, field) case "deletedAt": - return ec.fieldContext_EntityType_deletedAt(ctx, field) + return ec.fieldContext_OrgSubscriptionHistory_deletedAt(ctx, field) case "deletedBy": - return ec.fieldContext_EntityType_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_EntityType_tags(ctx, field) + return ec.fieldContext_OrgSubscriptionHistory_deletedBy(ctx, field) case "ownerID": - return ec.fieldContext_EntityType_ownerID(ctx, field) - case "name": - return ec.fieldContext_EntityType_name(ctx, field) - case "owner": - return ec.fieldContext_EntityType_owner(ctx, field) - case "entities": - return ec.fieldContext_EntityType_entities(ctx, field) + return ec.fieldContext_OrgSubscriptionHistory_ownerID(ctx, field) + case "stripeSubscriptionID": + return ec.fieldContext_OrgSubscriptionHistory_stripeSubscriptionID(ctx, field) + case "productTier": + return ec.fieldContext_OrgSubscriptionHistory_productTier(ctx, field) + case "stripeProductTierID": + return ec.fieldContext_OrgSubscriptionHistory_stripeProductTierID(ctx, field) + case "stripeSubscriptionStatus": + return ec.fieldContext_OrgSubscriptionHistory_stripeSubscriptionStatus(ctx, field) + case "active": + return ec.fieldContext_OrgSubscriptionHistory_active(ctx, field) + case "stripeCustomerID": + return ec.fieldContext_OrgSubscriptionHistory_stripeCustomerID(ctx, field) + case "expiresAt": + return ec.fieldContext_OrgSubscriptionHistory_expiresAt(ctx, field) + case "features": + return ec.fieldContext_OrgSubscriptionHistory_features(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type EntityType", field.Name) + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionHistory", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_contacts(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_contacts(ctx, field) +func (ec *executionContext) _OrgSubscriptionHistoryEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *generated.OrgSubscriptionHistoryEdge) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionHistoryEdge_cursor(ctx, field) if err != nil { return graphql.Null } @@ -175241,75 +176172,38 @@ func (ec *executionContext) _Organization_contacts(ctx context.Context, field gr }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Contacts(ctx) + return obj.Cursor, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.Contact) + res := resTmp.(entgql.Cursor[string]) fc.Result = res - return ec.marshalOContact2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐContactᚄ(ctx, field.Selections, res) + return ec.marshalNCursor2entgoᚗioᚋcontribᚋentgqlᚐCursor(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_contacts(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionHistoryEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionHistoryEdge", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Contact_id(ctx, field) - case "createdAt": - return ec.fieldContext_Contact_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Contact_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Contact_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Contact_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Contact_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Contact_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Contact_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Contact_ownerID(ctx, field) - case "fullName": - return ec.fieldContext_Contact_fullName(ctx, field) - case "title": - return ec.fieldContext_Contact_title(ctx, field) - case "company": - return ec.fieldContext_Contact_company(ctx, field) - case "email": - return ec.fieldContext_Contact_email(ctx, field) - case "phoneNumber": - return ec.fieldContext_Contact_phoneNumber(ctx, field) - case "address": - return ec.fieldContext_Contact_address(ctx, field) - case "status": - return ec.fieldContext_Contact_status(ctx, field) - case "owner": - return ec.fieldContext_Contact_owner(ctx, field) - case "entities": - return ec.fieldContext_Contact_entities(ctx, field) - case "files": - return ec.fieldContext_Contact_files(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Contact", field.Name) + return nil, errors.New("field of type Cursor does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_notes(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_notes(ctx, field) +func (ec *executionContext) _OrgSubscriptionSearchResult_orgSubscriptions(ctx context.Context, field graphql.CollectedField, obj *OrgSubscriptionSearchResult) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionSearchResult_orgSubscriptions(ctx, field) if err != nil { return graphql.Null } @@ -175322,7 +176216,7 @@ func (ec *executionContext) _Organization_notes(ctx context.Context, field graph }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Notes(ctx) + return obj.OrgSubscriptions, nil }) if err != nil { ec.Error(ctx, err) @@ -175331,56 +176225,64 @@ func (ec *executionContext) _Organization_notes(ctx context.Context, field graph if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Note) + res := resTmp.([]*generated.OrgSubscription) fc.Result = res - return ec.marshalONote2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteᚄ(ctx, field.Selections, res) + return ec.marshalOOrgSubscription2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionᚄ(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_notes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionSearchResult_orgSubscriptions(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionSearchResult", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "id": - return ec.fieldContext_Note_id(ctx, field) + return ec.fieldContext_OrgSubscription_id(ctx, field) case "createdAt": - return ec.fieldContext_Note_createdAt(ctx, field) + return ec.fieldContext_OrgSubscription_createdAt(ctx, field) case "updatedAt": - return ec.fieldContext_Note_updatedAt(ctx, field) + return ec.fieldContext_OrgSubscription_updatedAt(ctx, field) case "createdBy": - return ec.fieldContext_Note_createdBy(ctx, field) + return ec.fieldContext_OrgSubscription_createdBy(ctx, field) case "updatedBy": - return ec.fieldContext_Note_updatedBy(ctx, field) + return ec.fieldContext_OrgSubscription_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_OrgSubscription_tags(ctx, field) case "deletedAt": - return ec.fieldContext_Note_deletedAt(ctx, field) + return ec.fieldContext_OrgSubscription_deletedAt(ctx, field) case "deletedBy": - return ec.fieldContext_Note_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Note_tags(ctx, field) + return ec.fieldContext_OrgSubscription_deletedBy(ctx, field) case "ownerID": - return ec.fieldContext_Note_ownerID(ctx, field) - case "text": - return ec.fieldContext_Note_text(ctx, field) + return ec.fieldContext_OrgSubscription_ownerID(ctx, field) + case "stripeSubscriptionID": + return ec.fieldContext_OrgSubscription_stripeSubscriptionID(ctx, field) + case "productTier": + return ec.fieldContext_OrgSubscription_productTier(ctx, field) + case "stripeProductTierID": + return ec.fieldContext_OrgSubscription_stripeProductTierID(ctx, field) + case "stripeSubscriptionStatus": + return ec.fieldContext_OrgSubscription_stripeSubscriptionStatus(ctx, field) + case "active": + return ec.fieldContext_OrgSubscription_active(ctx, field) + case "stripeCustomerID": + return ec.fieldContext_OrgSubscription_stripeCustomerID(ctx, field) + case "expiresAt": + return ec.fieldContext_OrgSubscription_expiresAt(ctx, field) + case "features": + return ec.fieldContext_OrgSubscription_features(ctx, field) case "owner": - return ec.fieldContext_Note_owner(ctx, field) - case "entity": - return ec.fieldContext_Note_entity(ctx, field) - case "subcontrols": - return ec.fieldContext_Note_subcontrols(ctx, field) - case "program": - return ec.fieldContext_Note_program(ctx, field) + return ec.fieldContext_OrgSubscription_owner(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Note", field.Name) + return nil, fmt.Errorf("no field named %q was found under type OrgSubscription", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_tasks(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_tasks(ctx, field) +func (ec *executionContext) _OrgSubscriptionUpdatePayload_orgSubscription(ctx context.Context, field graphql.CollectedField, obj *OrgSubscriptionUpdatePayload) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_OrgSubscriptionUpdatePayload_orgSubscription(ctx, field) if err != nil { return graphql.Null } @@ -175393,85 +176295,76 @@ func (ec *executionContext) _Organization_tasks(ctx context.Context, field graph }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Tasks(ctx) + return obj.OrgSubscription, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.Task) + res := resTmp.(*generated.OrgSubscription) fc.Result = res - return ec.marshalOTask2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskᚄ(ctx, field.Selections, res) + return ec.marshalNOrgSubscription2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscription(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_tasks(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_OrgSubscriptionUpdatePayload_orgSubscription(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "Organization", + Object: "OrgSubscriptionUpdatePayload", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "id": - return ec.fieldContext_Task_id(ctx, field) + return ec.fieldContext_OrgSubscription_id(ctx, field) case "createdAt": - return ec.fieldContext_Task_createdAt(ctx, field) + return ec.fieldContext_OrgSubscription_createdAt(ctx, field) case "updatedAt": - return ec.fieldContext_Task_updatedAt(ctx, field) + return ec.fieldContext_OrgSubscription_updatedAt(ctx, field) case "createdBy": - return ec.fieldContext_Task_createdBy(ctx, field) + return ec.fieldContext_OrgSubscription_createdBy(ctx, field) case "updatedBy": - return ec.fieldContext_Task_updatedBy(ctx, field) + return ec.fieldContext_OrgSubscription_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_OrgSubscription_tags(ctx, field) case "deletedAt": - return ec.fieldContext_Task_deletedAt(ctx, field) + return ec.fieldContext_OrgSubscription_deletedAt(ctx, field) case "deletedBy": - return ec.fieldContext_Task_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Task_tags(ctx, field) - case "title": - return ec.fieldContext_Task_title(ctx, field) - case "description": - return ec.fieldContext_Task_description(ctx, field) - case "details": - return ec.fieldContext_Task_details(ctx, field) - case "status": - return ec.fieldContext_Task_status(ctx, field) - case "due": - return ec.fieldContext_Task_due(ctx, field) - case "completed": - return ec.fieldContext_Task_completed(ctx, field) - case "assigner": - return ec.fieldContext_Task_assigner(ctx, field) - case "assignee": - return ec.fieldContext_Task_assignee(ctx, field) - case "organization": - return ec.fieldContext_Task_organization(ctx, field) - case "group": - return ec.fieldContext_Task_group(ctx, field) - case "policy": - return ec.fieldContext_Task_policy(ctx, field) - case "procedure": - return ec.fieldContext_Task_procedure(ctx, field) - case "control": - return ec.fieldContext_Task_control(ctx, field) - case "controlObjective": - return ec.fieldContext_Task_controlObjective(ctx, field) - case "subcontrol": - return ec.fieldContext_Task_subcontrol(ctx, field) - case "program": - return ec.fieldContext_Task_program(ctx, field) + return ec.fieldContext_OrgSubscription_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_OrgSubscription_ownerID(ctx, field) + case "stripeSubscriptionID": + return ec.fieldContext_OrgSubscription_stripeSubscriptionID(ctx, field) + case "productTier": + return ec.fieldContext_OrgSubscription_productTier(ctx, field) + case "stripeProductTierID": + return ec.fieldContext_OrgSubscription_stripeProductTierID(ctx, field) + case "stripeSubscriptionStatus": + return ec.fieldContext_OrgSubscription_stripeSubscriptionStatus(ctx, field) + case "active": + return ec.fieldContext_OrgSubscription_active(ctx, field) + case "stripeCustomerID": + return ec.fieldContext_OrgSubscription_stripeCustomerID(ctx, field) + case "expiresAt": + return ec.fieldContext_OrgSubscription_expiresAt(ctx, field) + case "features": + return ec.fieldContext_OrgSubscription_features(ctx, field) + case "owner": + return ec.fieldContext_OrgSubscription_owner(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type Task", field.Name) + return nil, fmt.Errorf("no field named %q was found under type OrgSubscription", field.Name) }, } return fc, nil } -func (ec *executionContext) _Organization_programs(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_programs(ctx, field) +func (ec *executionContext) _Organization_id(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_id(ctx, field) if err != nil { return graphql.Null } @@ -175484,107 +176377,38 @@ func (ec *executionContext) _Organization_programs(ctx context.Context, field gr }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Programs(ctx) + return obj.ID, nil }) if err != nil { ec.Error(ctx, err) return graphql.Null } if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.([]*generated.Program) + res := resTmp.(string) fc.Result = res - return ec.marshalOProgram2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramᚄ(ctx, field.Selections, res) + return ec.marshalNID2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_programs(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Organization_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ Object: "Organization", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Program_id(ctx, field) - case "createdAt": - return ec.fieldContext_Program_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Program_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Program_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Program_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Program_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Program_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Program_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Program_ownerID(ctx, field) - case "name": - return ec.fieldContext_Program_name(ctx, field) - case "description": - return ec.fieldContext_Program_description(ctx, field) - case "status": - return ec.fieldContext_Program_status(ctx, field) - case "startDate": - return ec.fieldContext_Program_startDate(ctx, field) - case "endDate": - return ec.fieldContext_Program_endDate(ctx, field) - case "auditorReady": - return ec.fieldContext_Program_auditorReady(ctx, field) - case "auditorWriteComments": - return ec.fieldContext_Program_auditorWriteComments(ctx, field) - case "auditorReadComments": - return ec.fieldContext_Program_auditorReadComments(ctx, field) - case "owner": - return ec.fieldContext_Program_owner(ctx, field) - case "blockedGroups": - return ec.fieldContext_Program_blockedGroups(ctx, field) - case "editors": - return ec.fieldContext_Program_editors(ctx, field) - case "viewers": - return ec.fieldContext_Program_viewers(ctx, field) - case "controls": - return ec.fieldContext_Program_controls(ctx, field) - case "subcontrols": - return ec.fieldContext_Program_subcontrols(ctx, field) - case "controlobjectives": - return ec.fieldContext_Program_controlobjectives(ctx, field) - case "policies": - return ec.fieldContext_Program_policies(ctx, field) - case "procedures": - return ec.fieldContext_Program_procedures(ctx, field) - case "risks": - return ec.fieldContext_Program_risks(ctx, field) - case "tasks": - return ec.fieldContext_Program_tasks(ctx, field) - case "notes": - return ec.fieldContext_Program_notes(ctx, field) - case "files": - return ec.fieldContext_Program_files(ctx, field) - case "narratives": - return ec.fieldContext_Program_narratives(ctx, field) - case "actionplans": - return ec.fieldContext_Program_actionplans(ctx, field) - case "standards": - return ec.fieldContext_Program_standards(ctx, field) - case "users": - return ec.fieldContext_Program_users(ctx, field) - case "members": - return ec.fieldContext_Program_members(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Program", field.Name) + return nil, errors.New("field of type ID does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_procedures(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_procedures(ctx, field) +func (ec *executionContext) _Organization_createdAt(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_createdAt(ctx, field) if err != nil { return graphql.Null } @@ -175597,7 +176421,7 @@ func (ec *executionContext) _Organization_procedures(ctx context.Context, field }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Procedures(ctx) + return obj.CreatedAt, nil }) if err != nil { ec.Error(ctx, err) @@ -175606,82 +176430,26 @@ func (ec *executionContext) _Organization_procedures(ctx context.Context, field if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.Procedure) + res := resTmp.(time.Time) fc.Result = res - return ec.marshalOProcedure2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureᚄ(ctx, field.Selections, res) + return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_procedures(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Organization_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ Object: "Organization", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_Procedure_id(ctx, field) - case "createdAt": - return ec.fieldContext_Procedure_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_Procedure_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_Procedure_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_Procedure_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_Procedure_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_Procedure_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_Procedure_tags(ctx, field) - case "ownerID": - return ec.fieldContext_Procedure_ownerID(ctx, field) - case "name": - return ec.fieldContext_Procedure_name(ctx, field) - case "description": - return ec.fieldContext_Procedure_description(ctx, field) - case "status": - return ec.fieldContext_Procedure_status(ctx, field) - case "procedureType": - return ec.fieldContext_Procedure_procedureType(ctx, field) - case "version": - return ec.fieldContext_Procedure_version(ctx, field) - case "purposeAndScope": - return ec.fieldContext_Procedure_purposeAndScope(ctx, field) - case "background": - return ec.fieldContext_Procedure_background(ctx, field) - case "satisfies": - return ec.fieldContext_Procedure_satisfies(ctx, field) - case "details": - return ec.fieldContext_Procedure_details(ctx, field) - case "owner": - return ec.fieldContext_Procedure_owner(ctx, field) - case "blockedGroups": - return ec.fieldContext_Procedure_blockedGroups(ctx, field) - case "editors": - return ec.fieldContext_Procedure_editors(ctx, field) - case "control": - return ec.fieldContext_Procedure_control(ctx, field) - case "internalpolicy": - return ec.fieldContext_Procedure_internalpolicy(ctx, field) - case "narratives": - return ec.fieldContext_Procedure_narratives(ctx, field) - case "risks": - return ec.fieldContext_Procedure_risks(ctx, field) - case "tasks": - return ec.fieldContext_Procedure_tasks(ctx, field) - case "programs": - return ec.fieldContext_Procedure_programs(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type Procedure", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _Organization_internalpolicies(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_Organization_internalpolicies(ctx, field) +func (ec *executionContext) _Organization_updatedAt(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_updatedAt(ctx, field) if err != nil { return graphql.Null } @@ -175694,7 +176462,7 @@ func (ec *executionContext) _Organization_internalpolicies(ctx context.Context, }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Internalpolicies(ctx) + return obj.UpdatedAt, nil }) if err != nil { ec.Error(ctx, err) @@ -175703,41 +176471,4467 @@ func (ec *executionContext) _Organization_internalpolicies(ctx context.Context, if resTmp == nil { return graphql.Null } - res := resTmp.([]*generated.InternalPolicy) + res := resTmp.(time.Time) fc.Result = res - return ec.marshalOInternalPolicy2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyᚄ(ctx, field.Selections, res) + return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_Organization_internalpolicies(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Organization_updatedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ Object: "Organization", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "id": - return ec.fieldContext_InternalPolicy_id(ctx, field) - case "createdAt": - return ec.fieldContext_InternalPolicy_createdAt(ctx, field) - case "updatedAt": - return ec.fieldContext_InternalPolicy_updatedAt(ctx, field) - case "createdBy": - return ec.fieldContext_InternalPolicy_createdBy(ctx, field) - case "updatedBy": - return ec.fieldContext_InternalPolicy_updatedBy(ctx, field) - case "deletedAt": - return ec.fieldContext_InternalPolicy_deletedAt(ctx, field) - case "deletedBy": - return ec.fieldContext_InternalPolicy_deletedBy(ctx, field) - case "tags": - return ec.fieldContext_InternalPolicy_tags(ctx, field) - case "ownerID": - return ec.fieldContext_InternalPolicy_ownerID(ctx, field) - case "name": - return ec.fieldContext_InternalPolicy_name(ctx, field) - case "description": - return ec.fieldContext_InternalPolicy_description(ctx, field) + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_createdBy(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_createdBy(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.CreatedBy, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_createdBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_updatedBy(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_updatedBy(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.UpdatedBy, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_updatedBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_tags(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_tags(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Tags, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]string) + fc.Result = res + return ec.marshalOString2ᚕstringᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_tags(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_deletedAt(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_deletedAt(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.DeletedAt, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(time.Time) + fc.Result = res + return ec.marshalOTime2timeᚐTime(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_deletedAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_deletedBy(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_deletedBy(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.DeletedBy, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_deletedBy(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_name(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_name(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Name, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_displayName(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_displayName(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.DisplayName, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_displayName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_description(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_description(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Description, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalOString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_personalOrg(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_personalOrg(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.PersonalOrg, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(bool) + fc.Result = res + return ec.marshalOBoolean2bool(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_personalOrg(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Boolean does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_avatarRemoteURL(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_avatarRemoteURL(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.AvatarRemoteURL, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*string) + fc.Result = res + return ec.marshalOString2ᚖstring(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_avatarRemoteURL(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_dedicatedDb(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_dedicatedDb(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.DedicatedDb, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(bool) + fc.Result = res + return ec.marshalNBoolean2bool(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_dedicatedDb(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Boolean does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_controlCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_controlCreators(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ControlCreators(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_controlCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_controlObjectiveCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_controlObjectiveCreators(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ControlObjectiveCreators(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_controlObjectiveCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_groupCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_groupCreators(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.GroupCreators(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_groupCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_internalPolicyCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_internalPolicyCreators(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.InternalPolicyCreators(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_internalPolicyCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_narrativeCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_narrativeCreators(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.NarrativeCreators(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_narrativeCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_procedureCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_procedureCreators(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ProcedureCreators(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_procedureCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_programCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_programCreators(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ProgramCreators(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_programCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_riskCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_riskCreators(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.RiskCreators(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_riskCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_templateCreators(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_templateCreators(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.TemplateCreators(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_templateCreators(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_parent(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_parent(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Parent(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*generated.Organization) + fc.Result = res + return ec.marshalOOrganization2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganization(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_parent(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Organization_id(ctx, field) + case "createdAt": + return ec.fieldContext_Organization_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Organization_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Organization_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Organization_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_Organization_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_Organization_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Organization_deletedBy(ctx, field) + case "name": + return ec.fieldContext_Organization_name(ctx, field) + case "displayName": + return ec.fieldContext_Organization_displayName(ctx, field) + case "description": + return ec.fieldContext_Organization_description(ctx, field) + case "personalOrg": + return ec.fieldContext_Organization_personalOrg(ctx, field) + case "avatarRemoteURL": + return ec.fieldContext_Organization_avatarRemoteURL(ctx, field) + case "dedicatedDb": + return ec.fieldContext_Organization_dedicatedDb(ctx, field) + case "controlCreators": + return ec.fieldContext_Organization_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Organization_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Organization_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Organization_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Organization_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Organization_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Organization_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Organization_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Organization_templateCreators(ctx, field) + case "parent": + return ec.fieldContext_Organization_parent(ctx, field) + case "children": + return ec.fieldContext_Organization_children(ctx, field) + case "groups": + return ec.fieldContext_Organization_groups(ctx, field) + case "templates": + return ec.fieldContext_Organization_templates(ctx, field) + case "integrations": + return ec.fieldContext_Organization_integrations(ctx, field) + case "setting": + return ec.fieldContext_Organization_setting(ctx, field) + case "documentdata": + return ec.fieldContext_Organization_documentdata(ctx, field) + case "entitlements": + return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) + case "organizationEntitlement": + return ec.fieldContext_Organization_organizationEntitlement(ctx, field) + case "personalAccessTokens": + return ec.fieldContext_Organization_personalAccessTokens(ctx, field) + case "apiTokens": + return ec.fieldContext_Organization_apiTokens(ctx, field) + case "oauthprovider": + return ec.fieldContext_Organization_oauthprovider(ctx, field) + case "users": + return ec.fieldContext_Organization_users(ctx, field) + case "invites": + return ec.fieldContext_Organization_invites(ctx, field) + case "subscribers": + return ec.fieldContext_Organization_subscribers(ctx, field) + case "webhooks": + return ec.fieldContext_Organization_webhooks(ctx, field) + case "events": + return ec.fieldContext_Organization_events(ctx, field) + case "secrets": + return ec.fieldContext_Organization_secrets(ctx, field) + case "features": + return ec.fieldContext_Organization_features(ctx, field) + case "files": + return ec.fieldContext_Organization_files(ctx, field) + case "entitlementplans": + return ec.fieldContext_Organization_entitlementplans(ctx, field) + case "entitlementplanfeatures": + return ec.fieldContext_Organization_entitlementplanfeatures(ctx, field) + case "entities": + return ec.fieldContext_Organization_entities(ctx, field) + case "entitytypes": + return ec.fieldContext_Organization_entitytypes(ctx, field) + case "contacts": + return ec.fieldContext_Organization_contacts(ctx, field) + case "notes": + return ec.fieldContext_Organization_notes(ctx, field) + case "tasks": + return ec.fieldContext_Organization_tasks(ctx, field) + case "programs": + return ec.fieldContext_Organization_programs(ctx, field) + case "procedures": + return ec.fieldContext_Organization_procedures(ctx, field) + case "internalpolicies": + return ec.fieldContext_Organization_internalpolicies(ctx, field) + case "risks": + return ec.fieldContext_Organization_risks(ctx, field) + case "controlobjectives": + return ec.fieldContext_Organization_controlobjectives(ctx, field) + case "narratives": + return ec.fieldContext_Organization_narratives(ctx, field) + case "controls": + return ec.fieldContext_Organization_controls(ctx, field) + case "subcontrols": + return ec.fieldContext_Organization_subcontrols(ctx, field) + case "members": + return ec.fieldContext_Organization_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Organization", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_children(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_children(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Children(ctx, fc.Args["after"].(*entgql.Cursor[string]), fc.Args["first"].(*int), fc.Args["before"].(*entgql.Cursor[string]), fc.Args["last"].(*int), fc.Args["orderBy"].(*generated.OrganizationOrder), fc.Args["where"].(*generated.OrganizationWhereInput)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*generated.OrganizationConnection) + fc.Result = res + return ec.marshalNOrganizationConnection2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationConnection(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_children(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "edges": + return ec.fieldContext_OrganizationConnection_edges(ctx, field) + case "pageInfo": + return ec.fieldContext_OrganizationConnection_pageInfo(ctx, field) + case "totalCount": + return ec.fieldContext_OrganizationConnection_totalCount(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrganizationConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Organization_children_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Organization_groups(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_groups(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Groups(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Group) + fc.Result = res + return ec.marshalOGroup2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_groups(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Group_id(ctx, field) + case "createdAt": + return ec.fieldContext_Group_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Group_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Group_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Group_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Group_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Group_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Group_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Group_ownerID(ctx, field) + case "name": + return ec.fieldContext_Group_name(ctx, field) + case "description": + return ec.fieldContext_Group_description(ctx, field) + case "gravatarLogoURL": + return ec.fieldContext_Group_gravatarLogoURL(ctx, field) + case "logoURL": + return ec.fieldContext_Group_logoURL(ctx, field) + case "displayName": + return ec.fieldContext_Group_displayName(ctx, field) + case "owner": + return ec.fieldContext_Group_owner(ctx, field) + case "controlCreators": + return ec.fieldContext_Group_controlCreators(ctx, field) + case "controlObjectiveCreators": + return ec.fieldContext_Group_controlObjectiveCreators(ctx, field) + case "groupCreators": + return ec.fieldContext_Group_groupCreators(ctx, field) + case "internalPolicyCreators": + return ec.fieldContext_Group_internalPolicyCreators(ctx, field) + case "narrativeCreators": + return ec.fieldContext_Group_narrativeCreators(ctx, field) + case "procedureCreators": + return ec.fieldContext_Group_procedureCreators(ctx, field) + case "programCreators": + return ec.fieldContext_Group_programCreators(ctx, field) + case "riskCreators": + return ec.fieldContext_Group_riskCreators(ctx, field) + case "templateCreators": + return ec.fieldContext_Group_templateCreators(ctx, field) + case "procedureEditors": + return ec.fieldContext_Group_procedureEditors(ctx, field) + case "procedureBlockedGroups": + return ec.fieldContext_Group_procedureBlockedGroups(ctx, field) + case "internalpolicyEditors": + return ec.fieldContext_Group_internalpolicyEditors(ctx, field) + case "internalpolicyBlockedGroups": + return ec.fieldContext_Group_internalpolicyBlockedGroups(ctx, field) + case "programEditors": + return ec.fieldContext_Group_programEditors(ctx, field) + case "programBlockedGroups": + return ec.fieldContext_Group_programBlockedGroups(ctx, field) + case "programViewers": + return ec.fieldContext_Group_programViewers(ctx, field) + case "riskEditors": + return ec.fieldContext_Group_riskEditors(ctx, field) + case "riskBlockedGroups": + return ec.fieldContext_Group_riskBlockedGroups(ctx, field) + case "riskViewers": + return ec.fieldContext_Group_riskViewers(ctx, field) + case "controlobjectiveEditors": + return ec.fieldContext_Group_controlobjectiveEditors(ctx, field) + case "controlobjectiveBlockedGroups": + return ec.fieldContext_Group_controlobjectiveBlockedGroups(ctx, field) + case "controlobjectiveViewers": + return ec.fieldContext_Group_controlobjectiveViewers(ctx, field) + case "controlEditors": + return ec.fieldContext_Group_controlEditors(ctx, field) + case "controlBlockedGroups": + return ec.fieldContext_Group_controlBlockedGroups(ctx, field) + case "controlViewers": + return ec.fieldContext_Group_controlViewers(ctx, field) + case "narrativeEditors": + return ec.fieldContext_Group_narrativeEditors(ctx, field) + case "narrativeBlockedGroups": + return ec.fieldContext_Group_narrativeBlockedGroups(ctx, field) + case "narrativeViewers": + return ec.fieldContext_Group_narrativeViewers(ctx, field) + case "setting": + return ec.fieldContext_Group_setting(ctx, field) + case "users": + return ec.fieldContext_Group_users(ctx, field) + case "events": + return ec.fieldContext_Group_events(ctx, field) + case "integrations": + return ec.fieldContext_Group_integrations(ctx, field) + case "files": + return ec.fieldContext_Group_files(ctx, field) + case "tasks": + return ec.fieldContext_Group_tasks(ctx, field) + case "members": + return ec.fieldContext_Group_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Group", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_templates(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_templates(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Templates(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Template) + fc.Result = res + return ec.marshalOTemplate2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_templates(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Template_id(ctx, field) + case "createdAt": + return ec.fieldContext_Template_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Template_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Template_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Template_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Template_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Template_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Template_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Template_ownerID(ctx, field) + case "name": + return ec.fieldContext_Template_name(ctx, field) + case "templateType": + return ec.fieldContext_Template_templateType(ctx, field) + case "description": + return ec.fieldContext_Template_description(ctx, field) + case "jsonconfig": + return ec.fieldContext_Template_jsonconfig(ctx, field) + case "uischema": + return ec.fieldContext_Template_uischema(ctx, field) + case "owner": + return ec.fieldContext_Template_owner(ctx, field) + case "documents": + return ec.fieldContext_Template_documents(ctx, field) + case "files": + return ec.fieldContext_Template_files(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Template", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_integrations(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_integrations(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Integrations(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Integration) + fc.Result = res + return ec.marshalOIntegration2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_integrations(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Integration_id(ctx, field) + case "createdAt": + return ec.fieldContext_Integration_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Integration_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Integration_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Integration_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_Integration_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_Integration_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Integration_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_Integration_ownerID(ctx, field) + case "name": + return ec.fieldContext_Integration_name(ctx, field) + case "description": + return ec.fieldContext_Integration_description(ctx, field) + case "kind": + return ec.fieldContext_Integration_kind(ctx, field) + case "owner": + return ec.fieldContext_Integration_owner(ctx, field) + case "secrets": + return ec.fieldContext_Integration_secrets(ctx, field) + case "oauth2tokens": + return ec.fieldContext_Integration_oauth2tokens(ctx, field) + case "events": + return ec.fieldContext_Integration_events(ctx, field) + case "webhooks": + return ec.fieldContext_Integration_webhooks(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Integration", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_setting(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_setting(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Setting(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*generated.OrganizationSetting) + fc.Result = res + return ec.marshalOOrganizationSetting2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationSetting(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_setting(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_OrganizationSetting_id(ctx, field) + case "createdAt": + return ec.fieldContext_OrganizationSetting_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_OrganizationSetting_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_OrganizationSetting_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_OrganizationSetting_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_OrganizationSetting_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_OrganizationSetting_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_OrganizationSetting_deletedBy(ctx, field) + case "domains": + return ec.fieldContext_OrganizationSetting_domains(ctx, field) + case "billingContact": + return ec.fieldContext_OrganizationSetting_billingContact(ctx, field) + case "billingEmail": + return ec.fieldContext_OrganizationSetting_billingEmail(ctx, field) + case "billingPhone": + return ec.fieldContext_OrganizationSetting_billingPhone(ctx, field) + case "billingAddress": + return ec.fieldContext_OrganizationSetting_billingAddress(ctx, field) + case "taxIdentifier": + return ec.fieldContext_OrganizationSetting_taxIdentifier(ctx, field) + case "geoLocation": + return ec.fieldContext_OrganizationSetting_geoLocation(ctx, field) + case "organizationID": + return ec.fieldContext_OrganizationSetting_organizationID(ctx, field) + case "stripeID": + return ec.fieldContext_OrganizationSetting_stripeID(ctx, field) + case "organization": + return ec.fieldContext_OrganizationSetting_organization(ctx, field) + case "files": + return ec.fieldContext_OrganizationSetting_files(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrganizationSetting", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_documentdata(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_documentdata(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Documentdata(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.DocumentData) + fc.Result = res + return ec.marshalODocumentData2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐDocumentDataᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_documentdata(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_DocumentData_id(ctx, field) + case "createdAt": + return ec.fieldContext_DocumentData_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_DocumentData_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_DocumentData_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_DocumentData_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_DocumentData_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_DocumentData_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_DocumentData_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_DocumentData_ownerID(ctx, field) + case "templateID": + return ec.fieldContext_DocumentData_templateID(ctx, field) + case "data": + return ec.fieldContext_DocumentData_data(ctx, field) + case "owner": + return ec.fieldContext_DocumentData_owner(ctx, field) + case "template": + return ec.fieldContext_DocumentData_template(ctx, field) + case "entity": + return ec.fieldContext_DocumentData_entity(ctx, field) + case "files": + return ec.fieldContext_DocumentData_files(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type DocumentData", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_entitlements(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_entitlements(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Entitlements(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Entitlement) + fc.Result = res + return ec.marshalOEntitlement2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_entitlements(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Entitlement_id(ctx, field) + case "createdAt": + return ec.fieldContext_Entitlement_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Entitlement_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Entitlement_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Entitlement_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_Entitlement_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_Entitlement_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Entitlement_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_Entitlement_ownerID(ctx, field) + case "planID": + return ec.fieldContext_Entitlement_planID(ctx, field) + case "organizationID": + return ec.fieldContext_Entitlement_organizationID(ctx, field) + case "externalCustomerID": + return ec.fieldContext_Entitlement_externalCustomerID(ctx, field) + case "externalSubscriptionID": + return ec.fieldContext_Entitlement_externalSubscriptionID(ctx, field) + case "expires": + return ec.fieldContext_Entitlement_expires(ctx, field) + case "expiresAt": + return ec.fieldContext_Entitlement_expiresAt(ctx, field) + case "cancelled": + return ec.fieldContext_Entitlement_cancelled(ctx, field) + case "cancelledDate": + return ec.fieldContext_Entitlement_cancelledDate(ctx, field) + case "billStarting": + return ec.fieldContext_Entitlement_billStarting(ctx, field) + case "active": + return ec.fieldContext_Entitlement_active(ctx, field) + case "owner": + return ec.fieldContext_Entitlement_owner(ctx, field) + case "plan": + return ec.fieldContext_Entitlement_plan(ctx, field) + case "organization": + return ec.fieldContext_Entitlement_organization(ctx, field) + case "events": + return ec.fieldContext_Entitlement_events(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Entitlement", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_orgsubscriptions(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_orgsubscriptions(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Orgsubscriptions(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.OrgSubscription) + fc.Result = res + return ec.marshalOOrgSubscription2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_orgsubscriptions(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_OrgSubscription_id(ctx, field) + case "createdAt": + return ec.fieldContext_OrgSubscription_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_OrgSubscription_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_OrgSubscription_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_OrgSubscription_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_OrgSubscription_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_OrgSubscription_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_OrgSubscription_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_OrgSubscription_ownerID(ctx, field) + case "stripeSubscriptionID": + return ec.fieldContext_OrgSubscription_stripeSubscriptionID(ctx, field) + case "productTier": + return ec.fieldContext_OrgSubscription_productTier(ctx, field) + case "stripeProductTierID": + return ec.fieldContext_OrgSubscription_stripeProductTierID(ctx, field) + case "stripeSubscriptionStatus": + return ec.fieldContext_OrgSubscription_stripeSubscriptionStatus(ctx, field) + case "active": + return ec.fieldContext_OrgSubscription_active(ctx, field) + case "stripeCustomerID": + return ec.fieldContext_OrgSubscription_stripeCustomerID(ctx, field) + case "expiresAt": + return ec.fieldContext_OrgSubscription_expiresAt(ctx, field) + case "features": + return ec.fieldContext_OrgSubscription_features(ctx, field) + case "owner": + return ec.fieldContext_OrgSubscription_owner(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscription", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_organizationEntitlement(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_organizationEntitlement(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.OrganizationEntitlement(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Entitlement) + fc.Result = res + return ec.marshalOEntitlement2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_organizationEntitlement(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Entitlement_id(ctx, field) + case "createdAt": + return ec.fieldContext_Entitlement_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Entitlement_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Entitlement_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Entitlement_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_Entitlement_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_Entitlement_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Entitlement_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_Entitlement_ownerID(ctx, field) + case "planID": + return ec.fieldContext_Entitlement_planID(ctx, field) + case "organizationID": + return ec.fieldContext_Entitlement_organizationID(ctx, field) + case "externalCustomerID": + return ec.fieldContext_Entitlement_externalCustomerID(ctx, field) + case "externalSubscriptionID": + return ec.fieldContext_Entitlement_externalSubscriptionID(ctx, field) + case "expires": + return ec.fieldContext_Entitlement_expires(ctx, field) + case "expiresAt": + return ec.fieldContext_Entitlement_expiresAt(ctx, field) + case "cancelled": + return ec.fieldContext_Entitlement_cancelled(ctx, field) + case "cancelledDate": + return ec.fieldContext_Entitlement_cancelledDate(ctx, field) + case "billStarting": + return ec.fieldContext_Entitlement_billStarting(ctx, field) + case "active": + return ec.fieldContext_Entitlement_active(ctx, field) + case "owner": + return ec.fieldContext_Entitlement_owner(ctx, field) + case "plan": + return ec.fieldContext_Entitlement_plan(ctx, field) + case "organization": + return ec.fieldContext_Entitlement_organization(ctx, field) + case "events": + return ec.fieldContext_Entitlement_events(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Entitlement", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_personalAccessTokens(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_personalAccessTokens(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.PersonalAccessTokens(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.PersonalAccessToken) + fc.Result = res + return ec.marshalOPersonalAccessToken2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐPersonalAccessTokenᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_personalAccessTokens(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_PersonalAccessToken_id(ctx, field) + case "createdAt": + return ec.fieldContext_PersonalAccessToken_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_PersonalAccessToken_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_PersonalAccessToken_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_PersonalAccessToken_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_PersonalAccessToken_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_PersonalAccessToken_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_PersonalAccessToken_tags(ctx, field) + case "name": + return ec.fieldContext_PersonalAccessToken_name(ctx, field) + case "token": + return ec.fieldContext_PersonalAccessToken_token(ctx, field) + case "expiresAt": + return ec.fieldContext_PersonalAccessToken_expiresAt(ctx, field) + case "description": + return ec.fieldContext_PersonalAccessToken_description(ctx, field) + case "scopes": + return ec.fieldContext_PersonalAccessToken_scopes(ctx, field) + case "lastUsedAt": + return ec.fieldContext_PersonalAccessToken_lastUsedAt(ctx, field) + case "owner": + return ec.fieldContext_PersonalAccessToken_owner(ctx, field) + case "organizations": + return ec.fieldContext_PersonalAccessToken_organizations(ctx, field) + case "events": + return ec.fieldContext_PersonalAccessToken_events(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type PersonalAccessToken", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_apiTokens(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_apiTokens(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.APITokens(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.APIToken) + fc.Result = res + return ec.marshalOAPIToken2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐAPITokenᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_apiTokens(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_APIToken_id(ctx, field) + case "createdAt": + return ec.fieldContext_APIToken_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_APIToken_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_APIToken_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_APIToken_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_APIToken_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_APIToken_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_APIToken_tags(ctx, field) + case "ownerID": + return ec.fieldContext_APIToken_ownerID(ctx, field) + case "name": + return ec.fieldContext_APIToken_name(ctx, field) + case "token": + return ec.fieldContext_APIToken_token(ctx, field) + case "expiresAt": + return ec.fieldContext_APIToken_expiresAt(ctx, field) + case "description": + return ec.fieldContext_APIToken_description(ctx, field) + case "scopes": + return ec.fieldContext_APIToken_scopes(ctx, field) + case "lastUsedAt": + return ec.fieldContext_APIToken_lastUsedAt(ctx, field) + case "owner": + return ec.fieldContext_APIToken_owner(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type APIToken", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_oauthprovider(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_oauthprovider(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Oauthprovider(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.OauthProvider) + fc.Result = res + return ec.marshalOOauthProvider2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_oauthprovider(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_OauthProvider_id(ctx, field) + case "createdAt": + return ec.fieldContext_OauthProvider_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_OauthProvider_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_OauthProvider_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_OauthProvider_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_OauthProvider_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_OauthProvider_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_OauthProvider_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_OauthProvider_ownerID(ctx, field) + case "name": + return ec.fieldContext_OauthProvider_name(ctx, field) + case "clientID": + return ec.fieldContext_OauthProvider_clientID(ctx, field) + case "clientSecret": + return ec.fieldContext_OauthProvider_clientSecret(ctx, field) + case "redirectURL": + return ec.fieldContext_OauthProvider_redirectURL(ctx, field) + case "scopes": + return ec.fieldContext_OauthProvider_scopes(ctx, field) + case "authURL": + return ec.fieldContext_OauthProvider_authURL(ctx, field) + case "tokenURL": + return ec.fieldContext_OauthProvider_tokenURL(ctx, field) + case "authStyle": + return ec.fieldContext_OauthProvider_authStyle(ctx, field) + case "infoURL": + return ec.fieldContext_OauthProvider_infoURL(ctx, field) + case "owner": + return ec.fieldContext_OauthProvider_owner(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OauthProvider", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_users(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_users(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Users(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.User) + fc.Result = res + return ec.marshalOUser2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_users(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_User_id(ctx, field) + case "createdAt": + return ec.fieldContext_User_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_User_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_User_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_User_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_User_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_User_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_User_tags(ctx, field) + case "email": + return ec.fieldContext_User_email(ctx, field) + case "firstName": + return ec.fieldContext_User_firstName(ctx, field) + case "lastName": + return ec.fieldContext_User_lastName(ctx, field) + case "displayName": + return ec.fieldContext_User_displayName(ctx, field) + case "avatarRemoteURL": + return ec.fieldContext_User_avatarRemoteURL(ctx, field) + case "avatarLocalFile": + return ec.fieldContext_User_avatarLocalFile(ctx, field) + case "avatarLocalFileID": + return ec.fieldContext_User_avatarLocalFileID(ctx, field) + case "avatarUpdatedAt": + return ec.fieldContext_User_avatarUpdatedAt(ctx, field) + case "lastSeen": + return ec.fieldContext_User_lastSeen(ctx, field) + case "sub": + return ec.fieldContext_User_sub(ctx, field) + case "authProvider": + return ec.fieldContext_User_authProvider(ctx, field) + case "role": + return ec.fieldContext_User_role(ctx, field) + case "personalAccessTokens": + return ec.fieldContext_User_personalAccessTokens(ctx, field) + case "tfaSettings": + return ec.fieldContext_User_tfaSettings(ctx, field) + case "setting": + return ec.fieldContext_User_setting(ctx, field) + case "groups": + return ec.fieldContext_User_groups(ctx, field) + case "organizations": + return ec.fieldContext_User_organizations(ctx, field) + case "files": + return ec.fieldContext_User_files(ctx, field) + case "file": + return ec.fieldContext_User_file(ctx, field) + case "events": + return ec.fieldContext_User_events(ctx, field) + case "actionplans": + return ec.fieldContext_User_actionplans(ctx, field) + case "subcontrols": + return ec.fieldContext_User_subcontrols(ctx, field) + case "assignerTasks": + return ec.fieldContext_User_assignerTasks(ctx, field) + case "assigneeTasks": + return ec.fieldContext_User_assigneeTasks(ctx, field) + case "programs": + return ec.fieldContext_User_programs(ctx, field) + case "groupMemberships": + return ec.fieldContext_User_groupMemberships(ctx, field) + case "orgMemberships": + return ec.fieldContext_User_orgMemberships(ctx, field) + case "programMemberships": + return ec.fieldContext_User_programMemberships(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type User", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_invites(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_invites(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Invites(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Invite) + fc.Result = res + return ec.marshalOInvite2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_invites(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Invite_id(ctx, field) + case "createdAt": + return ec.fieldContext_Invite_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Invite_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Invite_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Invite_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Invite_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Invite_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_Invite_ownerID(ctx, field) + case "expires": + return ec.fieldContext_Invite_expires(ctx, field) + case "recipient": + return ec.fieldContext_Invite_recipient(ctx, field) + case "status": + return ec.fieldContext_Invite_status(ctx, field) + case "role": + return ec.fieldContext_Invite_role(ctx, field) + case "sendAttempts": + return ec.fieldContext_Invite_sendAttempts(ctx, field) + case "requestorID": + return ec.fieldContext_Invite_requestorID(ctx, field) + case "owner": + return ec.fieldContext_Invite_owner(ctx, field) + case "events": + return ec.fieldContext_Invite_events(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Invite", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_subscribers(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_subscribers(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Subscribers(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Subscriber) + fc.Result = res + return ec.marshalOSubscriber2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubscriberᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_subscribers(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Subscriber_id(ctx, field) + case "createdAt": + return ec.fieldContext_Subscriber_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Subscriber_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Subscriber_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Subscriber_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_Subscriber_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_Subscriber_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Subscriber_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_Subscriber_ownerID(ctx, field) + case "email": + return ec.fieldContext_Subscriber_email(ctx, field) + case "phoneNumber": + return ec.fieldContext_Subscriber_phoneNumber(ctx, field) + case "verifiedEmail": + return ec.fieldContext_Subscriber_verifiedEmail(ctx, field) + case "verifiedPhone": + return ec.fieldContext_Subscriber_verifiedPhone(ctx, field) + case "active": + return ec.fieldContext_Subscriber_active(ctx, field) + case "owner": + return ec.fieldContext_Subscriber_owner(ctx, field) + case "events": + return ec.fieldContext_Subscriber_events(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Subscriber", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_webhooks(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_webhooks(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Webhooks(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Webhook) + fc.Result = res + return ec.marshalOWebhook2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐWebhookᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_webhooks(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Webhook_id(ctx, field) + case "createdAt": + return ec.fieldContext_Webhook_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Webhook_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Webhook_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Webhook_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_Webhook_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_Webhook_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Webhook_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_Webhook_ownerID(ctx, field) + case "name": + return ec.fieldContext_Webhook_name(ctx, field) + case "description": + return ec.fieldContext_Webhook_description(ctx, field) + case "destinationURL": + return ec.fieldContext_Webhook_destinationURL(ctx, field) + case "enabled": + return ec.fieldContext_Webhook_enabled(ctx, field) + case "failures": + return ec.fieldContext_Webhook_failures(ctx, field) + case "lastError": + return ec.fieldContext_Webhook_lastError(ctx, field) + case "lastResponse": + return ec.fieldContext_Webhook_lastResponse(ctx, field) + case "owner": + return ec.fieldContext_Webhook_owner(ctx, field) + case "events": + return ec.fieldContext_Webhook_events(ctx, field) + case "integrations": + return ec.fieldContext_Webhook_integrations(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Webhook", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_events(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_events(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Events(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Event) + fc.Result = res + return ec.marshalOEvent2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_events(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Event_id(ctx, field) + case "createdAt": + return ec.fieldContext_Event_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Event_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Event_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Event_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_Event_tags(ctx, field) + case "eventID": + return ec.fieldContext_Event_eventID(ctx, field) + case "correlationID": + return ec.fieldContext_Event_correlationID(ctx, field) + case "eventType": + return ec.fieldContext_Event_eventType(ctx, field) + case "metadata": + return ec.fieldContext_Event_metadata(ctx, field) + case "user": + return ec.fieldContext_Event_user(ctx, field) + case "group": + return ec.fieldContext_Event_group(ctx, field) + case "integration": + return ec.fieldContext_Event_integration(ctx, field) + case "organization": + return ec.fieldContext_Event_organization(ctx, field) + case "invite": + return ec.fieldContext_Event_invite(ctx, field) + case "feature": + return ec.fieldContext_Event_feature(ctx, field) + case "entitlementplan": + return ec.fieldContext_Event_entitlementplan(ctx, field) + case "entitlementplanfeature": + return ec.fieldContext_Event_entitlementplanfeature(ctx, field) + case "personalAccessToken": + return ec.fieldContext_Event_personalAccessToken(ctx, field) + case "oauth2token": + return ec.fieldContext_Event_oauth2token(ctx, field) + case "hush": + return ec.fieldContext_Event_hush(ctx, field) + case "orgmembership": + return ec.fieldContext_Event_orgmembership(ctx, field) + case "groupmembership": + return ec.fieldContext_Event_groupmembership(ctx, field) + case "entitlement": + return ec.fieldContext_Event_entitlement(ctx, field) + case "webhook": + return ec.fieldContext_Event_webhook(ctx, field) + case "subscriber": + return ec.fieldContext_Event_subscriber(ctx, field) + case "file": + return ec.fieldContext_Event_file(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Event", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_secrets(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_secrets(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Secrets(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Hush) + fc.Result = res + return ec.marshalOHush2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_secrets(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Hush_id(ctx, field) + case "createdAt": + return ec.fieldContext_Hush_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Hush_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Hush_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Hush_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Hush_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Hush_deletedBy(ctx, field) + case "name": + return ec.fieldContext_Hush_name(ctx, field) + case "description": + return ec.fieldContext_Hush_description(ctx, field) + case "kind": + return ec.fieldContext_Hush_kind(ctx, field) + case "secretName": + return ec.fieldContext_Hush_secretName(ctx, field) + case "integrations": + return ec.fieldContext_Hush_integrations(ctx, field) + case "organization": + return ec.fieldContext_Hush_organization(ctx, field) + case "events": + return ec.fieldContext_Hush_events(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Hush", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_features(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_features(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Features(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Feature) + fc.Result = res + return ec.marshalOFeature2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_features(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Feature_id(ctx, field) + case "createdAt": + return ec.fieldContext_Feature_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Feature_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Feature_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Feature_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Feature_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Feature_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Feature_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Feature_ownerID(ctx, field) + case "name": + return ec.fieldContext_Feature_name(ctx, field) + case "displayName": + return ec.fieldContext_Feature_displayName(ctx, field) + case "enabled": + return ec.fieldContext_Feature_enabled(ctx, field) + case "description": + return ec.fieldContext_Feature_description(ctx, field) + case "metadata": + return ec.fieldContext_Feature_metadata(ctx, field) + case "stripeFeatureID": + return ec.fieldContext_Feature_stripeFeatureID(ctx, field) + case "owner": + return ec.fieldContext_Feature_owner(ctx, field) + case "plans": + return ec.fieldContext_Feature_plans(ctx, field) + case "events": + return ec.fieldContext_Feature_events(ctx, field) + case "features": + return ec.fieldContext_Feature_features(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Feature", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_files(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_files(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Files(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.File) + fc.Result = res + return ec.marshalOFile2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_files(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_File_id(ctx, field) + case "createdAt": + return ec.fieldContext_File_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_File_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_File_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_File_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_File_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_File_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_File_tags(ctx, field) + case "providedFileName": + return ec.fieldContext_File_providedFileName(ctx, field) + case "providedFileExtension": + return ec.fieldContext_File_providedFileExtension(ctx, field) + case "providedFileSize": + return ec.fieldContext_File_providedFileSize(ctx, field) + case "persistedFileSize": + return ec.fieldContext_File_persistedFileSize(ctx, field) + case "detectedMimeType": + return ec.fieldContext_File_detectedMimeType(ctx, field) + case "md5Hash": + return ec.fieldContext_File_md5Hash(ctx, field) + case "detectedContentType": + return ec.fieldContext_File_detectedContentType(ctx, field) + case "storeKey": + return ec.fieldContext_File_storeKey(ctx, field) + case "categoryType": + return ec.fieldContext_File_categoryType(ctx, field) + case "uri": + return ec.fieldContext_File_uri(ctx, field) + case "storageScheme": + return ec.fieldContext_File_storageScheme(ctx, field) + case "storageVolume": + return ec.fieldContext_File_storageVolume(ctx, field) + case "storagePath": + return ec.fieldContext_File_storagePath(ctx, field) + case "user": + return ec.fieldContext_File_user(ctx, field) + case "organization": + return ec.fieldContext_File_organization(ctx, field) + case "group": + return ec.fieldContext_File_group(ctx, field) + case "contact": + return ec.fieldContext_File_contact(ctx, field) + case "entity": + return ec.fieldContext_File_entity(ctx, field) + case "usersetting": + return ec.fieldContext_File_usersetting(ctx, field) + case "organizationsetting": + return ec.fieldContext_File_organizationsetting(ctx, field) + case "template": + return ec.fieldContext_File_template(ctx, field) + case "documentdata": + return ec.fieldContext_File_documentdata(ctx, field) + case "events": + return ec.fieldContext_File_events(ctx, field) + case "program": + return ec.fieldContext_File_program(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type File", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_entitlementplans(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_entitlementplans(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Entitlementplans(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.EntitlementPlan) + fc.Result = res + return ec.marshalOEntitlementPlan2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_entitlementplans(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_EntitlementPlan_id(ctx, field) + case "createdAt": + return ec.fieldContext_EntitlementPlan_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_EntitlementPlan_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_EntitlementPlan_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_EntitlementPlan_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_EntitlementPlan_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_EntitlementPlan_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_EntitlementPlan_tags(ctx, field) + case "ownerID": + return ec.fieldContext_EntitlementPlan_ownerID(ctx, field) + case "displayName": + return ec.fieldContext_EntitlementPlan_displayName(ctx, field) + case "name": + return ec.fieldContext_EntitlementPlan_name(ctx, field) + case "description": + return ec.fieldContext_EntitlementPlan_description(ctx, field) + case "version": + return ec.fieldContext_EntitlementPlan_version(ctx, field) + case "metadata": + return ec.fieldContext_EntitlementPlan_metadata(ctx, field) + case "stripeProductID": + return ec.fieldContext_EntitlementPlan_stripeProductID(ctx, field) + case "stripePriceID": + return ec.fieldContext_EntitlementPlan_stripePriceID(ctx, field) + case "owner": + return ec.fieldContext_EntitlementPlan_owner(ctx, field) + case "entitlements": + return ec.fieldContext_EntitlementPlan_entitlements(ctx, field) + case "baseFeatures": + return ec.fieldContext_EntitlementPlan_baseFeatures(ctx, field) + case "events": + return ec.fieldContext_EntitlementPlan_events(ctx, field) + case "features": + return ec.fieldContext_EntitlementPlan_features(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type EntitlementPlan", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_entitlementplanfeatures(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_entitlementplanfeatures(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Entitlementplanfeatures(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.EntitlementPlanFeature) + fc.Result = res + return ec.marshalOEntitlementPlanFeature2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanFeatureᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_entitlementplanfeatures(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_EntitlementPlanFeature_id(ctx, field) + case "createdAt": + return ec.fieldContext_EntitlementPlanFeature_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_EntitlementPlanFeature_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_EntitlementPlanFeature_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_EntitlementPlanFeature_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_EntitlementPlanFeature_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_EntitlementPlanFeature_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_EntitlementPlanFeature_tags(ctx, field) + case "ownerID": + return ec.fieldContext_EntitlementPlanFeature_ownerID(ctx, field) + case "metadata": + return ec.fieldContext_EntitlementPlanFeature_metadata(ctx, field) + case "planID": + return ec.fieldContext_EntitlementPlanFeature_planID(ctx, field) + case "stripeProductID": + return ec.fieldContext_EntitlementPlanFeature_stripeProductID(ctx, field) + case "featureID": + return ec.fieldContext_EntitlementPlanFeature_featureID(ctx, field) + case "stripeFeatureID": + return ec.fieldContext_EntitlementPlanFeature_stripeFeatureID(ctx, field) + case "owner": + return ec.fieldContext_EntitlementPlanFeature_owner(ctx, field) + case "plan": + return ec.fieldContext_EntitlementPlanFeature_plan(ctx, field) + case "feature": + return ec.fieldContext_EntitlementPlanFeature_feature(ctx, field) + case "events": + return ec.fieldContext_EntitlementPlanFeature_events(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type EntitlementPlanFeature", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_entities(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_entities(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Entities(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Entity) + fc.Result = res + return ec.marshalOEntity2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_entities(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Entity_id(ctx, field) + case "createdAt": + return ec.fieldContext_Entity_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Entity_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Entity_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Entity_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Entity_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Entity_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Entity_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Entity_ownerID(ctx, field) + case "name": + return ec.fieldContext_Entity_name(ctx, field) + case "displayName": + return ec.fieldContext_Entity_displayName(ctx, field) + case "description": + return ec.fieldContext_Entity_description(ctx, field) + case "domains": + return ec.fieldContext_Entity_domains(ctx, field) + case "entityTypeID": + return ec.fieldContext_Entity_entityTypeID(ctx, field) + case "status": + return ec.fieldContext_Entity_status(ctx, field) + case "owner": + return ec.fieldContext_Entity_owner(ctx, field) + case "contacts": + return ec.fieldContext_Entity_contacts(ctx, field) + case "documents": + return ec.fieldContext_Entity_documents(ctx, field) + case "notes": + return ec.fieldContext_Entity_notes(ctx, field) + case "files": + return ec.fieldContext_Entity_files(ctx, field) + case "entityType": + return ec.fieldContext_Entity_entityType(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Entity", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_entitytypes(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_entitytypes(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Entitytypes(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.EntityType) + fc.Result = res + return ec.marshalOEntityType2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityTypeᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_entitytypes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_EntityType_id(ctx, field) + case "createdAt": + return ec.fieldContext_EntityType_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_EntityType_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_EntityType_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_EntityType_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_EntityType_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_EntityType_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_EntityType_tags(ctx, field) + case "ownerID": + return ec.fieldContext_EntityType_ownerID(ctx, field) + case "name": + return ec.fieldContext_EntityType_name(ctx, field) + case "owner": + return ec.fieldContext_EntityType_owner(ctx, field) + case "entities": + return ec.fieldContext_EntityType_entities(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type EntityType", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_contacts(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_contacts(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Contacts(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Contact) + fc.Result = res + return ec.marshalOContact2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐContactᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_contacts(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Contact_id(ctx, field) + case "createdAt": + return ec.fieldContext_Contact_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Contact_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Contact_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Contact_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Contact_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Contact_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Contact_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Contact_ownerID(ctx, field) + case "fullName": + return ec.fieldContext_Contact_fullName(ctx, field) + case "title": + return ec.fieldContext_Contact_title(ctx, field) + case "company": + return ec.fieldContext_Contact_company(ctx, field) + case "email": + return ec.fieldContext_Contact_email(ctx, field) + case "phoneNumber": + return ec.fieldContext_Contact_phoneNumber(ctx, field) + case "address": + return ec.fieldContext_Contact_address(ctx, field) + case "status": + return ec.fieldContext_Contact_status(ctx, field) + case "owner": + return ec.fieldContext_Contact_owner(ctx, field) + case "entities": + return ec.fieldContext_Contact_entities(ctx, field) + case "files": + return ec.fieldContext_Contact_files(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Contact", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_notes(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_notes(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Notes(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Note) + fc.Result = res + return ec.marshalONote2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_notes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Note_id(ctx, field) + case "createdAt": + return ec.fieldContext_Note_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Note_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Note_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Note_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Note_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Note_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Note_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Note_ownerID(ctx, field) + case "text": + return ec.fieldContext_Note_text(ctx, field) + case "owner": + return ec.fieldContext_Note_owner(ctx, field) + case "entity": + return ec.fieldContext_Note_entity(ctx, field) + case "subcontrols": + return ec.fieldContext_Note_subcontrols(ctx, field) + case "program": + return ec.fieldContext_Note_program(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Note", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_tasks(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_tasks(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Tasks(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Task) + fc.Result = res + return ec.marshalOTask2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_tasks(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Task_id(ctx, field) + case "createdAt": + return ec.fieldContext_Task_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Task_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Task_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Task_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Task_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Task_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Task_tags(ctx, field) + case "title": + return ec.fieldContext_Task_title(ctx, field) + case "description": + return ec.fieldContext_Task_description(ctx, field) + case "details": + return ec.fieldContext_Task_details(ctx, field) + case "status": + return ec.fieldContext_Task_status(ctx, field) + case "due": + return ec.fieldContext_Task_due(ctx, field) + case "completed": + return ec.fieldContext_Task_completed(ctx, field) + case "assigner": + return ec.fieldContext_Task_assigner(ctx, field) + case "assignee": + return ec.fieldContext_Task_assignee(ctx, field) + case "organization": + return ec.fieldContext_Task_organization(ctx, field) + case "group": + return ec.fieldContext_Task_group(ctx, field) + case "policy": + return ec.fieldContext_Task_policy(ctx, field) + case "procedure": + return ec.fieldContext_Task_procedure(ctx, field) + case "control": + return ec.fieldContext_Task_control(ctx, field) + case "controlObjective": + return ec.fieldContext_Task_controlObjective(ctx, field) + case "subcontrol": + return ec.fieldContext_Task_subcontrol(ctx, field) + case "program": + return ec.fieldContext_Task_program(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Task", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_programs(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_programs(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Programs(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Program) + fc.Result = res + return ec.marshalOProgram2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_programs(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Program_id(ctx, field) + case "createdAt": + return ec.fieldContext_Program_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Program_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Program_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Program_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Program_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Program_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Program_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Program_ownerID(ctx, field) + case "name": + return ec.fieldContext_Program_name(ctx, field) + case "description": + return ec.fieldContext_Program_description(ctx, field) + case "status": + return ec.fieldContext_Program_status(ctx, field) + case "startDate": + return ec.fieldContext_Program_startDate(ctx, field) + case "endDate": + return ec.fieldContext_Program_endDate(ctx, field) + case "auditorReady": + return ec.fieldContext_Program_auditorReady(ctx, field) + case "auditorWriteComments": + return ec.fieldContext_Program_auditorWriteComments(ctx, field) + case "auditorReadComments": + return ec.fieldContext_Program_auditorReadComments(ctx, field) + case "owner": + return ec.fieldContext_Program_owner(ctx, field) + case "blockedGroups": + return ec.fieldContext_Program_blockedGroups(ctx, field) + case "editors": + return ec.fieldContext_Program_editors(ctx, field) + case "viewers": + return ec.fieldContext_Program_viewers(ctx, field) + case "controls": + return ec.fieldContext_Program_controls(ctx, field) + case "subcontrols": + return ec.fieldContext_Program_subcontrols(ctx, field) + case "controlobjectives": + return ec.fieldContext_Program_controlobjectives(ctx, field) + case "policies": + return ec.fieldContext_Program_policies(ctx, field) + case "procedures": + return ec.fieldContext_Program_procedures(ctx, field) + case "risks": + return ec.fieldContext_Program_risks(ctx, field) + case "tasks": + return ec.fieldContext_Program_tasks(ctx, field) + case "notes": + return ec.fieldContext_Program_notes(ctx, field) + case "files": + return ec.fieldContext_Program_files(ctx, field) + case "narratives": + return ec.fieldContext_Program_narratives(ctx, field) + case "actionplans": + return ec.fieldContext_Program_actionplans(ctx, field) + case "standards": + return ec.fieldContext_Program_standards(ctx, field) + case "users": + return ec.fieldContext_Program_users(ctx, field) + case "members": + return ec.fieldContext_Program_members(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Program", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_procedures(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_procedures(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Procedures(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.Procedure) + fc.Result = res + return ec.marshalOProcedure2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_procedures(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_Procedure_id(ctx, field) + case "createdAt": + return ec.fieldContext_Procedure_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_Procedure_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_Procedure_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_Procedure_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_Procedure_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_Procedure_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_Procedure_tags(ctx, field) + case "ownerID": + return ec.fieldContext_Procedure_ownerID(ctx, field) + case "name": + return ec.fieldContext_Procedure_name(ctx, field) + case "description": + return ec.fieldContext_Procedure_description(ctx, field) + case "status": + return ec.fieldContext_Procedure_status(ctx, field) + case "procedureType": + return ec.fieldContext_Procedure_procedureType(ctx, field) + case "version": + return ec.fieldContext_Procedure_version(ctx, field) + case "purposeAndScope": + return ec.fieldContext_Procedure_purposeAndScope(ctx, field) + case "background": + return ec.fieldContext_Procedure_background(ctx, field) + case "satisfies": + return ec.fieldContext_Procedure_satisfies(ctx, field) + case "details": + return ec.fieldContext_Procedure_details(ctx, field) + case "owner": + return ec.fieldContext_Procedure_owner(ctx, field) + case "blockedGroups": + return ec.fieldContext_Procedure_blockedGroups(ctx, field) + case "editors": + return ec.fieldContext_Procedure_editors(ctx, field) + case "control": + return ec.fieldContext_Procedure_control(ctx, field) + case "internalpolicy": + return ec.fieldContext_Procedure_internalpolicy(ctx, field) + case "narratives": + return ec.fieldContext_Procedure_narratives(ctx, field) + case "risks": + return ec.fieldContext_Procedure_risks(ctx, field) + case "tasks": + return ec.fieldContext_Procedure_tasks(ctx, field) + case "programs": + return ec.fieldContext_Procedure_programs(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type Procedure", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _Organization_internalpolicies(ctx context.Context, field graphql.CollectedField, obj *generated.Organization) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Organization_internalpolicies(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Internalpolicies(ctx) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*generated.InternalPolicy) + fc.Result = res + return ec.marshalOInternalPolicy2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Organization_internalpolicies(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Organization", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_InternalPolicy_id(ctx, field) + case "createdAt": + return ec.fieldContext_InternalPolicy_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_InternalPolicy_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_InternalPolicy_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_InternalPolicy_updatedBy(ctx, field) + case "deletedAt": + return ec.fieldContext_InternalPolicy_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_InternalPolicy_deletedBy(ctx, field) + case "tags": + return ec.fieldContext_InternalPolicy_tags(ctx, field) + case "ownerID": + return ec.fieldContext_InternalPolicy_ownerID(ctx, field) + case "name": + return ec.fieldContext_InternalPolicy_name(ctx, field) + case "description": + return ec.fieldContext_InternalPolicy_description(ctx, field) case "status": return ec.fieldContext_InternalPolicy_status(ctx, field) case "policyType": @@ -176451,6 +181645,8 @@ func (ec *executionContext) fieldContext_OrganizationBulkCreatePayload_organizat return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -176760,6 +181956,8 @@ func (ec *executionContext) fieldContext_OrganizationCreatePayload_organization( return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -176965,6 +182163,8 @@ func (ec *executionContext) fieldContext_OrganizationEdge_node(_ context.Context return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -178151,6 +183351,8 @@ func (ec *executionContext) fieldContext_OrganizationSearchResult_organizations( return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -179012,6 +184214,8 @@ func (ec *executionContext) fieldContext_OrganizationSetting_organization(_ cont return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -181028,6 +186232,8 @@ func (ec *executionContext) fieldContext_OrganizationUpdatePayload_organization( return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -182060,6 +187266,8 @@ func (ec *executionContext) fieldContext_PersonalAccessToken_organizations(_ con return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -183686,6 +188894,8 @@ func (ec *executionContext) fieldContext_Procedure_owner(_ context.Context, fiel return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -187313,6 +192523,8 @@ func (ec *executionContext) fieldContext_Program_owner(_ context.Context, field return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -196215,6 +201427,132 @@ func (ec *executionContext) fieldContext_Query_orgMembershipHistories(ctx contex return fc, nil } +func (ec *executionContext) _Query_orgSubscriptions(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_orgSubscriptions(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().OrgSubscriptions(rctx, fc.Args["after"].(*entgql.Cursor[string]), fc.Args["first"].(*int), fc.Args["before"].(*entgql.Cursor[string]), fc.Args["last"].(*int), fc.Args["where"].(*generated.OrgSubscriptionWhereInput)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*generated.OrgSubscriptionConnection) + fc.Result = res + return ec.marshalNOrgSubscriptionConnection2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionConnection(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_orgSubscriptions(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "edges": + return ec.fieldContext_OrgSubscriptionConnection_edges(ctx, field) + case "pageInfo": + return ec.fieldContext_OrgSubscriptionConnection_pageInfo(ctx, field) + case "totalCount": + return ec.fieldContext_OrgSubscriptionConnection_totalCount(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_orgSubscriptions_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Query_orgSubscriptionHistories(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_orgSubscriptionHistories(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().OrgSubscriptionHistories(rctx, fc.Args["after"].(*entgql.Cursor[string]), fc.Args["first"].(*int), fc.Args["before"].(*entgql.Cursor[string]), fc.Args["last"].(*int), fc.Args["where"].(*generated.OrgSubscriptionHistoryWhereInput)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*generated.OrgSubscriptionHistoryConnection) + fc.Result = res + return ec.marshalNOrgSubscriptionHistoryConnection2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryConnection(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_orgSubscriptionHistories(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "edges": + return ec.fieldContext_OrgSubscriptionHistoryConnection_edges(ctx, field) + case "pageInfo": + return ec.fieldContext_OrgSubscriptionHistoryConnection_pageInfo(ctx, field) + case "totalCount": + return ec.fieldContext_OrgSubscriptionHistoryConnection_totalCount(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionHistoryConnection", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_orgSubscriptionHistories_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Query_organizations(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { fc, err := ec.fieldContext_Query_organizations(ctx, field) if err != nil { @@ -199315,6 +204653,62 @@ func (ec *executionContext) fieldContext_Query_adminOhAuthTooTokenSearch(ctx con return fc, nil } +func (ec *executionContext) _Query_adminOrgSubscriptionSearch(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_adminOrgSubscriptionSearch(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().AdminOrgSubscriptionSearch(rctx, fc.Args["query"].(string)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*OrgSubscriptionSearchResult) + fc.Result = res + return ec.marshalOOrgSubscriptionSearchResult2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionSearchResult(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_adminOrgSubscriptionSearch(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "orgSubscriptions": + return ec.fieldContext_OrgSubscriptionSearchResult_orgSubscriptions(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionSearchResult", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_adminOrgSubscriptionSearch_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Query_adminOrganizationSearch(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { fc, err := ec.fieldContext_Query_adminOrganizationSearch(ctx, field) if err != nil { @@ -202624,6 +208018,8 @@ func (ec *executionContext) fieldContext_Query_organization(ctx context.Context, return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -202876,6 +208272,99 @@ func (ec *executionContext) fieldContext_Query_orgMembership(ctx context.Context return fc, nil } +func (ec *executionContext) _Query_orgSubscription(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_orgSubscription(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().OrgSubscription(rctx, fc.Args["id"].(string)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*generated.OrgSubscription) + fc.Result = res + return ec.marshalNOrgSubscription2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscription(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_orgSubscription(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_OrgSubscription_id(ctx, field) + case "createdAt": + return ec.fieldContext_OrgSubscription_createdAt(ctx, field) + case "updatedAt": + return ec.fieldContext_OrgSubscription_updatedAt(ctx, field) + case "createdBy": + return ec.fieldContext_OrgSubscription_createdBy(ctx, field) + case "updatedBy": + return ec.fieldContext_OrgSubscription_updatedBy(ctx, field) + case "tags": + return ec.fieldContext_OrgSubscription_tags(ctx, field) + case "deletedAt": + return ec.fieldContext_OrgSubscription_deletedAt(ctx, field) + case "deletedBy": + return ec.fieldContext_OrgSubscription_deletedBy(ctx, field) + case "ownerID": + return ec.fieldContext_OrgSubscription_ownerID(ctx, field) + case "stripeSubscriptionID": + return ec.fieldContext_OrgSubscription_stripeSubscriptionID(ctx, field) + case "productTier": + return ec.fieldContext_OrgSubscription_productTier(ctx, field) + case "stripeProductTierID": + return ec.fieldContext_OrgSubscription_stripeProductTierID(ctx, field) + case "stripeSubscriptionStatus": + return ec.fieldContext_OrgSubscription_stripeSubscriptionStatus(ctx, field) + case "active": + return ec.fieldContext_OrgSubscription_active(ctx, field) + case "stripeCustomerID": + return ec.fieldContext_OrgSubscription_stripeCustomerID(ctx, field) + case "expiresAt": + return ec.fieldContext_OrgSubscription_expiresAt(ctx, field) + case "features": + return ec.fieldContext_OrgSubscription_features(ctx, field) + case "owner": + return ec.fieldContext_OrgSubscription_owner(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscription", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_orgSubscription_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Query_personalAccessToken(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { fc, err := ec.fieldContext_Query_personalAccessToken(ctx, field) if err != nil { @@ -204573,6 +210062,62 @@ func (ec *executionContext) fieldContext_Query_ohAuthTooTokenSearch(ctx context. return fc, nil } +func (ec *executionContext) _Query_orgSubscriptionSearch(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_orgSubscriptionSearch(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().OrgSubscriptionSearch(rctx, fc.Args["query"].(string)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*OrgSubscriptionSearchResult) + fc.Result = res + return ec.marshalOOrgSubscriptionSearchResult2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionSearchResult(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_orgSubscriptionSearch(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "orgSubscriptions": + return ec.fieldContext_OrgSubscriptionSearchResult_orgSubscriptions(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type OrgSubscriptionSearchResult", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_orgSubscriptionSearch_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Query_organizationSearch(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { fc, err := ec.fieldContext_Query_organizationSearch(ctx, field) if err != nil { @@ -207456,6 +213001,8 @@ func (ec *executionContext) fieldContext_Risk_owner(_ context.Context, field gra return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -214590,6 +220137,8 @@ func (ec *executionContext) fieldContext_Subcontrol_owner(_ context.Context, fie return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -218059,6 +223608,8 @@ func (ec *executionContext) fieldContext_Subscriber_owner(_ context.Context, fie return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -220831,6 +226382,8 @@ func (ec *executionContext) fieldContext_Task_organization(_ context.Context, fi return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -224023,6 +229576,8 @@ func (ec *executionContext) fieldContext_Template_owner(_ context.Context, field return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -227174,6 +232729,8 @@ func (ec *executionContext) fieldContext_User_organizations(_ context.Context, f return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -231052,6 +236609,8 @@ func (ec *executionContext) fieldContext_UserSetting_defaultOrg(_ context.Contex return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -233773,6 +239332,8 @@ func (ec *executionContext) fieldContext_Webhook_owner(_ context.Context, field return ec.fieldContext_Organization_documentdata(ctx, field) case "entitlements": return ec.fieldContext_Organization_entitlements(ctx, field) + case "orgsubscriptions": + return ec.fieldContext_Organization_orgsubscriptions(ctx, field) case "organizationEntitlement": return ec.fieldContext_Organization_organizationEntitlement(ctx, field) case "personalAccessTokens": @@ -255253,6 +260814,96 @@ func (ec *executionContext) unmarshalInputCreateOrgMembershipInput(ctx context.C return it, nil } +func (ec *executionContext) unmarshalInputCreateOrgSubscriptionInput(ctx context.Context, obj interface{}) (generated.CreateOrgSubscriptionInput, error) { + var it generated.CreateOrgSubscriptionInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"tags", "stripeSubscriptionID", "productTier", "stripeProductTierID", "stripeSubscriptionStatus", "active", "stripeCustomerID", "expiresAt", "features", "ownerID"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "tags": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tags")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.Tags = data + case "stripeSubscriptionID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionID = data + case "productTier": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTier")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTier = data + case "stripeProductTierID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierID = data + case "stripeSubscriptionStatus": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatus")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatus = data + case "active": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("active")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.Active = data + case "stripeCustomerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerID = data + case "expiresAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAt = data + case "features": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("features")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.Features = data + case "ownerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerID = data + } + } + + return it, nil +} + func (ec *executionContext) unmarshalInputCreateOrganizationInput(ctx context.Context, obj interface{}) (generated.CreateOrganizationInput, error) { var it generated.CreateOrganizationInput asMap := map[string]interface{}{} @@ -255260,7 +260911,7 @@ func (ec *executionContext) unmarshalInputCreateOrganizationInput(ctx context.Co asMap[k] = v } - fieldsInOrder := [...]string{"tags", "name", "displayName", "description", "personalOrg", "avatarRemoteURL", "dedicatedDb", "controlCreatorIDs", "controlObjectiveCreatorIDs", "groupCreatorIDs", "internalPolicyCreatorIDs", "narrativeCreatorIDs", "procedureCreatorIDs", "programCreatorIDs", "riskCreatorIDs", "templateCreatorIDs", "parentID", "groupIDs", "templateIDs", "integrationIDs", "settingID", "documentdatumIDs", "entitlementIDs", "organizationEntitlementIDs", "personalAccessTokenIDs", "apiTokenIDs", "oauthproviderIDs", "userIDs", "inviteIDs", "subscriberIDs", "webhookIDs", "eventIDs", "secretIDs", "featureIDs", "fileIDs", "entitlementplanIDs", "entityIDs", "entitytypeIDs", "contactIDs", "noteIDs", "taskIDs", "programIDs", "procedureIDs", "internalpolicyIDs", "riskIDs", "controlobjectiveIDs", "narrativeIDs", "controlIDs", "subcontrolIDs", "createOrgSettings"} + fieldsInOrder := [...]string{"tags", "name", "displayName", "description", "personalOrg", "avatarRemoteURL", "dedicatedDb", "controlCreatorIDs", "controlObjectiveCreatorIDs", "groupCreatorIDs", "internalPolicyCreatorIDs", "narrativeCreatorIDs", "procedureCreatorIDs", "programCreatorIDs", "riskCreatorIDs", "templateCreatorIDs", "parentID", "groupIDs", "templateIDs", "integrationIDs", "settingID", "documentdatumIDs", "entitlementIDs", "orgsubscriptionIDs", "organizationEntitlementIDs", "personalAccessTokenIDs", "apiTokenIDs", "oauthproviderIDs", "userIDs", "inviteIDs", "subscriberIDs", "webhookIDs", "eventIDs", "secretIDs", "featureIDs", "fileIDs", "entitlementplanIDs", "entityIDs", "entitytypeIDs", "contactIDs", "noteIDs", "taskIDs", "programIDs", "procedureIDs", "internalpolicyIDs", "riskIDs", "controlobjectiveIDs", "narrativeIDs", "controlIDs", "subcontrolIDs", "createOrgSettings"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -255428,6 +261079,13 @@ func (ec *executionContext) unmarshalInputCreateOrganizationInput(ctx context.Co return it, err } it.EntitlementIDs = data + case "orgsubscriptionIDs": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("orgsubscriptionIDs")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.OrgsubscriptionIDs = data case "organizationEntitlementIDs": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationEntitlementIDs")) data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) @@ -271695,392 +277353,1343 @@ func (ec *executionContext) unmarshalInputEntityWhereInput(ctx context.Context, if err != nil { return it, err } - it.DisplayNameNotIn = data - case "displayNameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGT")) + it.DisplayNameNotIn = data + case "displayNameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameGT = data + case "displayNameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameGTE = data + case "displayNameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameLT = data + case "displayNameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameLTE = data + case "displayNameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameContains = data + case "displayNameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameHasPrefix = data + case "displayNameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameHasSuffix = data + case "displayNameIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameIsNil = data + case "displayNameNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameNotNil = data + case "displayNameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameEqualFold = data + case "displayNameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameContainsFold = data + case "entityTypeID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeID")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeID = data + case "entityTypeIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDNEQ = data + case "entityTypeIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDIn = data + case "entityTypeIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDNotIn = data + case "entityTypeIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDGT = data + case "entityTypeIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDGTE = data + case "entityTypeIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDLT = data + case "entityTypeIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDLTE = data + case "entityTypeIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDContains")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDContains = data + case "entityTypeIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDHasPrefix")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDHasPrefix = data + case "entityTypeIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDHasSuffix")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDHasSuffix = data + case "entityTypeIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDIsNil = data + case "entityTypeIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDNotNil = data + case "entityTypeIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDEqualFold = data + case "entityTypeIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EntityTypeIDContainsFold = data + case "status": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("status")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Status = data + case "statusNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusNEQ = data + case "statusIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StatusIn = data + case "statusNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StatusNotIn = data + case "statusGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusGT = data + case "statusGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusGTE = data + case "statusLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusLT = data + case "statusLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusLTE = data + case "statusContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusContains = data + case "statusHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusHasPrefix = data + case "statusHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusHasSuffix = data + case "statusIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StatusIsNil = data + case "statusNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StatusNotNil = data + case "statusEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusEqualFold = data + case "statusContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StatusContainsFold = data + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOwnerWith = data + case "hasContacts": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasContacts")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasContacts = data + case "hasContactsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasContactsWith")) + data, err := ec.unmarshalOContactWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐContactWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasContactsWith = data + case "hasDocuments": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasDocuments")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasDocuments = data + case "hasDocumentsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasDocumentsWith")) + data, err := ec.unmarshalODocumentDataWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐDocumentDataWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasDocumentsWith = data + case "hasNotes": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNotes")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasNotes = data + case "hasNotesWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNotesWith")) + data, err := ec.unmarshalONoteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasNotesWith = data + case "hasFiles": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFiles")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasFiles = data + case "hasFilesWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFilesWith")) + data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasFilesWith = data + case "hasEntityType": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntityType")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEntityType = data + case "hasEntityTypeWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntityTypeWith")) + data, err := ec.unmarshalOEntityTypeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityTypeWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEntityTypeWith = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputEventHistoryWhereInput(ctx context.Context, obj interface{}) (generated.EventHistoryWhereInput, error) { + var it generated.EventHistoryWhereInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "eventID", "eventIDNEQ", "eventIDIn", "eventIDNotIn", "eventIDGT", "eventIDGTE", "eventIDLT", "eventIDLTE", "eventIDContains", "eventIDHasPrefix", "eventIDHasSuffix", "eventIDIsNil", "eventIDNotNil", "eventIDEqualFold", "eventIDContainsFold", "correlationID", "correlationIDNEQ", "correlationIDIn", "correlationIDNotIn", "correlationIDGT", "correlationIDGTE", "correlationIDLT", "correlationIDLTE", "correlationIDContains", "correlationIDHasPrefix", "correlationIDHasSuffix", "correlationIDIsNil", "correlationIDNotNil", "correlationIDEqualFold", "correlationIDContainsFold", "eventType", "eventTypeNEQ", "eventTypeIn", "eventTypeNotIn", "eventTypeGT", "eventTypeGTE", "eventTypeLT", "eventTypeLTE", "eventTypeContains", "eventTypeHasPrefix", "eventTypeHasSuffix", "eventTypeEqualFold", "eventTypeContainsFold"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) + data, err := ec.unmarshalOEventHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventHistoryWhereInput(ctx, v) + if err != nil { + return it, err + } + it.Not = data + case "and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) + data, err := ec.unmarshalOEventHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventHistoryWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.And = data + case "or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) + data, err := ec.unmarshalOEventHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventHistoryWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.Or = data + case "id": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ID = data + case "idNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDNEQ = data + case "idIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.IDIn = data + case "idNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.IDNotIn = data + case "idGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDGT = data + case "idGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDGTE = data + case "idLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDLT = data + case "idLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDLTE = data + case "idEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDEqualFold = data + case "idContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOEventHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOEventHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOEventHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOEventHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationNotIn = data + case "createdAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAt = data + case "createdAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtNEQ = data + case "createdAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtIn = data + case "createdAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtNotIn = data + case "createdAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtGT = data + case "createdAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtGTE = data + case "createdAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtLT = data + case "createdAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtLTE = data + case "createdAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtIsNil = data + case "createdAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtNotNil = data + case "updatedAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAt = data + case "updatedAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtNEQ = data + case "updatedAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtIn = data + case "updatedAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtNotIn = data + case "updatedAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtGT = data + case "updatedAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtGTE = data + case "updatedAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtLT = data + case "updatedAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtLTE = data + case "updatedAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtIsNil = data + case "updatedAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtNotNil = data + case "createdBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedBy = data + case "createdByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByNEQ = data + case "createdByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.CreatedByIn = data + case "createdByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.CreatedByNotIn = data + case "createdByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByGT = data + case "createdByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByGTE = data + case "createdByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByLT = data + case "createdByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByLTE = data + case "createdByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByContains = data + case "createdByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByHasPrefix = data + case "createdByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByHasSuffix = data + case "createdByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.CreatedByIsNil = data + case "createdByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.CreatedByNotNil = data + case "createdByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByEqualFold = data + case "createdByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByContainsFold = data + case "updatedBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedBy = data + case "updatedByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByNEQ = data + case "updatedByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByIn = data + case "updatedByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByNotIn = data + case "updatedByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameGT = data - case "displayNameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGTE")) + it.UpdatedByGT = data + case "updatedByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameGTE = data - case "displayNameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLT")) + it.UpdatedByGTE = data + case "updatedByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameLT = data - case "displayNameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLTE")) + it.UpdatedByLT = data + case "updatedByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameLTE = data - case "displayNameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContains")) + it.UpdatedByLTE = data + case "updatedByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameContains = data - case "displayNameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasPrefix")) + it.UpdatedByContains = data + case "updatedByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameHasPrefix = data - case "displayNameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasSuffix")) + it.UpdatedByHasPrefix = data + case "updatedByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameHasSuffix = data - case "displayNameIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIsNil")) + it.UpdatedByHasSuffix = data + case "updatedByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DisplayNameIsNil = data - case "displayNameNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotNil")) + it.UpdatedByIsNil = data + case "updatedByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DisplayNameNotNil = data - case "displayNameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameEqualFold")) + it.UpdatedByNotNil = data + case "updatedByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameEqualFold = data - case "displayNameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContainsFold")) + it.UpdatedByEqualFold = data + case "updatedByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameContainsFold = data - case "entityTypeID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.UpdatedByContainsFold = data + case "eventID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeID = data - case "entityTypeIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventID = data + case "eventIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDNEQ = data - case "entityTypeIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.EventIDNEQ = data + case "eventIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.EntityTypeIDIn = data - case "entityTypeIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.EventIDIn = data + case "eventIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.EntityTypeIDNotIn = data - case "entityTypeIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventIDNotIn = data + case "eventIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDGT = data - case "entityTypeIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventIDGT = data + case "eventIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDGTE = data - case "entityTypeIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventIDGTE = data + case "eventIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDLT = data - case "entityTypeIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventIDLT = data + case "eventIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDLTE = data - case "entityTypeIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDContains")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventIDLTE = data + case "eventIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDContains = data - case "entityTypeIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDHasPrefix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventIDContains = data + case "eventIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDHasPrefix = data - case "entityTypeIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDHasSuffix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventIDHasPrefix = data + case "eventIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDHasSuffix = data - case "entityTypeIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDIsNil")) + it.EventIDHasSuffix = data + case "eventIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.EntityTypeIDIsNil = data - case "entityTypeIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDNotNil")) + it.EventIDIsNil = data + case "eventIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.EntityTypeIDNotNil = data - case "entityTypeIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventIDNotNil = data + case "eventIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDEqualFold = data - case "entityTypeIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("entityTypeIDContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.EventIDEqualFold = data + case "eventIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EntityTypeIDContainsFold = data - case "status": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("status")) + it.EventIDContainsFold = data + case "correlationID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Status = data - case "statusNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNEQ")) + it.CorrelationID = data + case "correlationIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusNEQ = data - case "statusIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusIn")) + it.CorrelationIDNEQ = data + case "correlationIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.StatusIn = data - case "statusNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNotIn")) + it.CorrelationIDIn = data + case "correlationIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.StatusNotIn = data - case "statusGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusGT")) + it.CorrelationIDNotIn = data + case "correlationIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusGT = data - case "statusGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusGTE")) + it.CorrelationIDGT = data + case "correlationIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusGTE = data - case "statusLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusLT")) + it.CorrelationIDGTE = data + case "correlationIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusLT = data - case "statusLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusLTE")) + it.CorrelationIDLT = data + case "correlationIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusLTE = data - case "statusContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusContains")) + it.CorrelationIDLTE = data + case "correlationIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusContains = data - case "statusHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusHasPrefix")) + it.CorrelationIDContains = data + case "correlationIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusHasPrefix = data - case "statusHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusHasSuffix")) + it.CorrelationIDHasPrefix = data + case "correlationIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusHasSuffix = data - case "statusIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusIsNil")) + it.CorrelationIDHasSuffix = data + case "correlationIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StatusIsNil = data - case "statusNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNotNil")) + it.CorrelationIDIsNil = data + case "correlationIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StatusNotNil = data - case "statusEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusEqualFold")) + it.CorrelationIDNotNil = data + case "correlationIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusEqualFold = data - case "statusContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusContainsFold")) + it.CorrelationIDEqualFold = data + case "correlationIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusContainsFold = data - case "hasOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.CorrelationIDContainsFold = data + case "eventType": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventType")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOwner = data - case "hasOwnerWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + it.EventType = data + case "eventTypeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOwnerWith = data - case "hasContacts": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasContacts")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.EventTypeNEQ = data + case "eventTypeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasContacts = data - case "hasContactsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasContactsWith")) - data, err := ec.unmarshalOContactWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐContactWhereInputᚄ(ctx, v) + it.EventTypeIn = data + case "eventTypeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasContactsWith = data - case "hasDocuments": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasDocuments")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.EventTypeNotIn = data + case "eventTypeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasDocuments = data - case "hasDocumentsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasDocumentsWith")) - data, err := ec.unmarshalODocumentDataWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐDocumentDataWhereInputᚄ(ctx, v) + it.EventTypeGT = data + case "eventTypeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasDocumentsWith = data - case "hasNotes": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNotes")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.EventTypeGTE = data + case "eventTypeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasNotes = data - case "hasNotesWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNotesWith")) - data, err := ec.unmarshalONoteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteWhereInputᚄ(ctx, v) + it.EventTypeLT = data + case "eventTypeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasNotesWith = data - case "hasFiles": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFiles")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.EventTypeLTE = data + case "eventTypeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasFiles = data - case "hasFilesWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFilesWith")) - data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) + it.EventTypeContains = data + case "eventTypeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasFilesWith = data - case "hasEntityType": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntityType")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.EventTypeHasPrefix = data + case "eventTypeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEntityType = data - case "hasEntityTypeWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntityTypeWith")) - data, err := ec.unmarshalOEntityTypeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityTypeWhereInputᚄ(ctx, v) + it.EventTypeHasSuffix = data + case "eventTypeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEntityTypeWith = data + it.EventTypeEqualFold = data + case "eventTypeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EventTypeContainsFold = data } } return it, nil } -func (ec *executionContext) unmarshalInputEventHistoryWhereInput(ctx context.Context, obj interface{}) (generated.EventHistoryWhereInput, error) { - var it generated.EventHistoryWhereInput +func (ec *executionContext) unmarshalInputEventWhereInput(ctx context.Context, obj interface{}) (generated.EventWhereInput, error) { + var it generated.EventWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "eventID", "eventIDNEQ", "eventIDIn", "eventIDNotIn", "eventIDGT", "eventIDGTE", "eventIDLT", "eventIDLTE", "eventIDContains", "eventIDHasPrefix", "eventIDHasSuffix", "eventIDIsNil", "eventIDNotNil", "eventIDEqualFold", "eventIDContainsFold", "correlationID", "correlationIDNEQ", "correlationIDIn", "correlationIDNotIn", "correlationIDGT", "correlationIDGTE", "correlationIDLT", "correlationIDLTE", "correlationIDContains", "correlationIDHasPrefix", "correlationIDHasSuffix", "correlationIDIsNil", "correlationIDNotNil", "correlationIDEqualFold", "correlationIDContainsFold", "eventType", "eventTypeNEQ", "eventTypeIn", "eventTypeNotIn", "eventTypeGT", "eventTypeGTE", "eventTypeLT", "eventTypeLTE", "eventTypeContains", "eventTypeHasPrefix", "eventTypeHasSuffix", "eventTypeEqualFold", "eventTypeContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "eventID", "eventIDNEQ", "eventIDIn", "eventIDNotIn", "eventIDGT", "eventIDGTE", "eventIDLT", "eventIDLTE", "eventIDContains", "eventIDHasPrefix", "eventIDHasSuffix", "eventIDIsNil", "eventIDNotNil", "eventIDEqualFold", "eventIDContainsFold", "correlationID", "correlationIDNEQ", "correlationIDIn", "correlationIDNotIn", "correlationIDGT", "correlationIDGTE", "correlationIDLT", "correlationIDLTE", "correlationIDContains", "correlationIDHasPrefix", "correlationIDHasSuffix", "correlationIDIsNil", "correlationIDNotNil", "correlationIDEqualFold", "correlationIDContainsFold", "eventType", "eventTypeNEQ", "eventTypeIn", "eventTypeNotIn", "eventTypeGT", "eventTypeGTE", "eventTypeLT", "eventTypeLTE", "eventTypeContains", "eventTypeHasPrefix", "eventTypeHasSuffix", "eventTypeEqualFold", "eventTypeContainsFold", "hasUser", "hasUserWith", "hasGroup", "hasGroupWith", "hasIntegration", "hasIntegrationWith", "hasOrganization", "hasOrganizationWith", "hasInvite", "hasInviteWith", "hasFeature", "hasFeatureWith", "hasEntitlementplan", "hasEntitlementplanWith", "hasEntitlementplanfeature", "hasEntitlementplanfeatureWith", "hasPersonalAccessToken", "hasPersonalAccessTokenWith", "hasOauth2token", "hasOauth2tokenWith", "hasHush", "hasHushWith", "hasOrgmembership", "hasOrgmembershipWith", "hasGroupmembership", "hasGroupmembershipWith", "hasEntitlement", "hasEntitlementWith", "hasWebhook", "hasWebhookWith", "hasSubscriber", "hasSubscriberWith", "hasFile", "hasFileWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -272089,21 +278698,21 @@ func (ec *executionContext) unmarshalInputEventHistoryWhereInput(ctx context.Con switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOEventHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventHistoryWhereInput(ctx, v) + data, err := ec.unmarshalOEventWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOEventHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOEventHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -272178,195 +278787,6 @@ func (ec *executionContext) unmarshalInputEventHistoryWhereInput(ctx context.Con return it, err } it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOEventHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOEventHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOEventHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOEventHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -272996,139 +279416,566 @@ func (ec *executionContext) unmarshalInputEventHistoryWhereInput(ctx context.Con if err != nil { return it, err } - it.EventTypeHasPrefix = data - case "eventTypeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.EventTypeHasPrefix = data + case "eventTypeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EventTypeHasSuffix = data + case "eventTypeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EventTypeEqualFold = data + case "eventTypeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.EventTypeContainsFold = data + case "hasUser": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUser")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasUser = data + case "hasUserWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUserWith")) + data, err := ec.unmarshalOUserWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasUserWith = data + case "hasGroup": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroup")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasGroup = data + case "hasGroupWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupWith")) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasGroupWith = data + case "hasIntegration": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegration")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasIntegration = data + case "hasIntegrationWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrationWith")) + data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasIntegrationWith = data + case "hasOrganization": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganization")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOrganization = data + case "hasOrganizationWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOrganizationWith = data + case "hasInvite": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInvite")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasInvite = data + case "hasInviteWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInviteWith")) + data, err := ec.unmarshalOInviteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasInviteWith = data + case "hasFeature": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFeature")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasFeature = data + case "hasFeatureWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFeatureWith")) + data, err := ec.unmarshalOFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasFeatureWith = data + case "hasEntitlementplan": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementplan")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEntitlementplan = data + case "hasEntitlementplanWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementplanWith")) + data, err := ec.unmarshalOEntitlementPlanWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEntitlementplanWith = data + case "hasEntitlementplanfeature": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementplanfeature")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEntitlementplanfeature = data + case "hasEntitlementplanfeatureWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementplanfeatureWith")) + data, err := ec.unmarshalOEntitlementPlanFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanFeatureWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEntitlementplanfeatureWith = data + case "hasPersonalAccessToken": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPersonalAccessToken")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasPersonalAccessToken = data + case "hasPersonalAccessTokenWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPersonalAccessTokenWith")) + data, err := ec.unmarshalOPersonalAccessTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐPersonalAccessTokenWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasPersonalAccessTokenWith = data + case "hasOauth2token": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOauth2token")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOauth2token = data + case "hasOauth2tokenWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOauth2tokenWith")) + data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOauth2tokenWith = data + case "hasHush": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasHush")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasHush = data + case "hasHushWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasHushWith")) + data, err := ec.unmarshalOHushWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasHushWith = data + case "hasOrgmembership": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrgmembership")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOrgmembership = data + case "hasOrgmembershipWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrgmembershipWith")) + data, err := ec.unmarshalOOrgMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOrgmembershipWith = data + case "hasGroupmembership": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupmembership")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasGroupmembership = data + case "hasGroupmembershipWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupmembershipWith")) + data, err := ec.unmarshalOGroupMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasGroupmembershipWith = data + case "hasEntitlement": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlement")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEntitlement = data + case "hasEntitlementWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementWith")) + data, err := ec.unmarshalOEntitlementWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEntitlementWith = data + case "hasWebhook": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasWebhook")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasWebhook = data + case "hasWebhookWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasWebhookWith")) + data, err := ec.unmarshalOWebhookWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐWebhookWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasWebhookWith = data + case "hasSubscriber": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSubscriber")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasSubscriber = data + case "hasSubscriberWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSubscriberWith")) + data, err := ec.unmarshalOSubscriberWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubscriberWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasSubscriberWith = data + case "hasFile": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFile")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasFile = data + case "hasFileWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFileWith")) + data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasFileWith = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputFeatureHistoryWhereInput(ctx context.Context, obj interface{}) (generated.FeatureHistoryWhereInput, error) { + var it generated.FeatureHistoryWhereInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameIsNil", "displayNameNotNil", "displayNameEqualFold", "displayNameContainsFold", "enabled", "enabledNEQ", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "stripeFeatureID", "stripeFeatureIDNEQ", "stripeFeatureIDIn", "stripeFeatureIDNotIn", "stripeFeatureIDGT", "stripeFeatureIDGTE", "stripeFeatureIDLT", "stripeFeatureIDLTE", "stripeFeatureIDContains", "stripeFeatureIDHasPrefix", "stripeFeatureIDHasSuffix", "stripeFeatureIDIsNil", "stripeFeatureIDNotNil", "stripeFeatureIDEqualFold", "stripeFeatureIDContainsFold"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) + data, err := ec.unmarshalOFeatureHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureHistoryWhereInput(ctx, v) + if err != nil { + return it, err + } + it.Not = data + case "and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) + data, err := ec.unmarshalOFeatureHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureHistoryWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.And = data + case "or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) + data, err := ec.unmarshalOFeatureHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureHistoryWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.Or = data + case "id": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ID = data + case "idNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDNEQ = data + case "idIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.IDIn = data + case "idNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.IDNotIn = data + case "idGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDGT = data + case "idGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDGTE = data + case "idLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDLT = data + case "idLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDLTE = data + case "idEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDEqualFold = data + case "idContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.EventTypeHasSuffix = data - case "eventTypeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeEqualFold")) + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeEqualFold = data - case "eventTypeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeContainsFold")) + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeContainsFold = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputEventWhereInput(ctx context.Context, obj interface{}) (generated.EventWhereInput, error) { - var it generated.EventWhereInput - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "eventID", "eventIDNEQ", "eventIDIn", "eventIDNotIn", "eventIDGT", "eventIDGTE", "eventIDLT", "eventIDLTE", "eventIDContains", "eventIDHasPrefix", "eventIDHasSuffix", "eventIDIsNil", "eventIDNotNil", "eventIDEqualFold", "eventIDContainsFold", "correlationID", "correlationIDNEQ", "correlationIDIn", "correlationIDNotIn", "correlationIDGT", "correlationIDGTE", "correlationIDLT", "correlationIDLTE", "correlationIDContains", "correlationIDHasPrefix", "correlationIDHasSuffix", "correlationIDIsNil", "correlationIDNotNil", "correlationIDEqualFold", "correlationIDContainsFold", "eventType", "eventTypeNEQ", "eventTypeIn", "eventTypeNotIn", "eventTypeGT", "eventTypeGTE", "eventTypeLT", "eventTypeLTE", "eventTypeContains", "eventTypeHasPrefix", "eventTypeHasSuffix", "eventTypeEqualFold", "eventTypeContainsFold", "hasUser", "hasUserWith", "hasGroup", "hasGroupWith", "hasIntegration", "hasIntegrationWith", "hasOrganization", "hasOrganizationWith", "hasInvite", "hasInviteWith", "hasFeature", "hasFeatureWith", "hasEntitlementplan", "hasEntitlementplanWith", "hasEntitlementplanfeature", "hasEntitlementplanfeatureWith", "hasPersonalAccessToken", "hasPersonalAccessTokenWith", "hasOauth2token", "hasOauth2tokenWith", "hasHush", "hasHushWith", "hasOrgmembership", "hasOrgmembershipWith", "hasGroupmembership", "hasGroupmembershipWith", "hasEntitlement", "hasEntitlementWith", "hasWebhook", "hasWebhookWith", "hasSubscriber", "hasSubscriberWith", "hasFile", "hasFileWith"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "not": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOEventWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInput(ctx, v) + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Not = data - case "and": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.And = data - case "or": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Or = data - case "id": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ID = data - case "idNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDNEQ = data - case "idIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.IDIn = data - case "idNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.IDNotIn = data - case "idGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDGT = data - case "idGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDGTE = data - case "idLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOFeatureHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } - it.IDLT = data - case "idLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOFeatureHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } - it.IDLTE = data - case "idEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOFeatureHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } - it.IDEqualFold = data - case "idContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOFeatureHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } - it.IDContainsFold = data + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -273479,845 +280326,817 @@ func (ec *executionContext) unmarshalInputEventWhereInput(ctx context.Context, o return it, err } it.UpdatedByContainsFold = data - case "eventID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.EventID = data - case "eventIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.EventIDNEQ = data - case "eventIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.EventIDIn = data - case "eventIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + case "deletedAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.EventIDNotIn = data - case "eventIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAt = data + case "deletedAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.EventIDGT = data - case "eventIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtNEQ = data + case "deletedAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.EventIDGTE = data - case "eventIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtIn = data + case "deletedAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.EventIDLT = data - case "eventIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtNotIn = data + case "deletedAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.EventIDLTE = data - case "eventIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtGT = data + case "deletedAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.EventIDContains = data - case "eventIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtGTE = data + case "deletedAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.EventIDHasPrefix = data - case "eventIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtLT = data + case "deletedAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.EventIDHasSuffix = data - case "eventIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDIsNil")) + it.DeletedAtLTE = data + case "deletedAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.EventIDIsNil = data - case "eventIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDNotNil")) + it.DeletedAtIsNil = data + case "deletedAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.EventIDNotNil = data - case "eventIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.EventIDEqualFold = data - case "eventIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.EventIDContainsFold = data - case "correlationID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationID")) + it.DeletedAtNotNil = data + case "deletedBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedBy")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationID = data - case "correlationIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDNEQ")) + it.DeletedBy = data + case "deletedByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDNEQ = data - case "correlationIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDIn")) + it.DeletedByNEQ = data + case "deletedByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CorrelationIDIn = data - case "correlationIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDNotIn")) + it.DeletedByIn = data + case "deletedByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CorrelationIDNotIn = data - case "correlationIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDGT")) + it.DeletedByNotIn = data + case "deletedByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDGT = data - case "correlationIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDGTE")) + it.DeletedByGT = data + case "deletedByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDGTE = data - case "correlationIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDLT")) + it.DeletedByGTE = data + case "deletedByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDLT = data - case "correlationIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDLTE")) + it.DeletedByLT = data + case "deletedByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDLTE = data - case "correlationIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDContains")) + it.DeletedByLTE = data + case "deletedByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDContains = data - case "correlationIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDHasPrefix")) + it.DeletedByContains = data + case "deletedByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDHasPrefix = data - case "correlationIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDHasSuffix")) + it.DeletedByHasPrefix = data + case "deletedByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDHasSuffix = data - case "correlationIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDIsNil")) + it.DeletedByHasSuffix = data + case "deletedByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CorrelationIDIsNil = data - case "correlationIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDNotNil")) + it.DeletedByIsNil = data + case "deletedByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CorrelationIDNotNil = data - case "correlationIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDEqualFold")) + it.DeletedByNotNil = data + case "deletedByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDEqualFold = data - case "correlationIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("correlationIDContainsFold")) + it.DeletedByEqualFold = data + case "deletedByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CorrelationIDContainsFold = data - case "eventType": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventType")) + it.DeletedByContainsFold = data + case "ownerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventType = data - case "eventTypeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeNEQ")) + it.OwnerID = data + case "ownerIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeNEQ = data - case "eventTypeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeIn")) + it.OwnerIDNEQ = data + case "ownerIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.EventTypeIn = data - case "eventTypeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeNotIn")) + it.OwnerIDIn = data + case "ownerIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.EventTypeNotIn = data - case "eventTypeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeGT")) + it.OwnerIDNotIn = data + case "ownerIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeGT = data - case "eventTypeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeGTE")) + it.OwnerIDGT = data + case "ownerIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeGTE = data - case "eventTypeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeLT")) + it.OwnerIDGTE = data + case "ownerIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeLT = data - case "eventTypeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeLTE")) + it.OwnerIDLT = data + case "ownerIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeLTE = data - case "eventTypeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeContains")) + it.OwnerIDLTE = data + case "ownerIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeContains = data - case "eventTypeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeHasPrefix")) + it.OwnerIDContains = data + case "ownerIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeHasPrefix = data - case "eventTypeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeHasSuffix")) + it.OwnerIDHasPrefix = data + case "ownerIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeHasSuffix = data - case "eventTypeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.OwnerIDHasSuffix = data + case "ownerIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.EventTypeEqualFold = data - case "eventTypeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eventTypeContainsFold")) + it.OwnerIDIsNil = data + case "ownerIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDNotNil = data + case "ownerIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.EventTypeContainsFold = data - case "hasUser": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUser")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.OwnerIDEqualFold = data + case "ownerIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasUser = data - case "hasUserWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUserWith")) - data, err := ec.unmarshalOUserWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserWhereInputᚄ(ctx, v) + it.OwnerIDContainsFold = data + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasUserWith = data - case "hasGroup": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroup")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.Name = data + case "nameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasGroup = data - case "hasGroupWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupWith")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + it.NameNEQ = data + case "nameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasGroupWith = data - case "hasIntegration": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegration")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameIn = data + case "nameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasIntegration = data - case "hasIntegrationWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrationWith")) - data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) + it.NameNotIn = data + case "nameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasIntegrationWith = data - case "hasOrganization": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganization")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameGT = data + case "nameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOrganization = data - case "hasOrganizationWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + it.NameGTE = data + case "nameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOrganizationWith = data - case "hasInvite": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInvite")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameLT = data + case "nameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasInvite = data - case "hasInviteWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInviteWith")) - data, err := ec.unmarshalOInviteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteWhereInputᚄ(ctx, v) + it.NameLTE = data + case "nameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasInviteWith = data - case "hasFeature": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFeature")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameContains = data + case "nameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasFeature = data - case "hasFeatureWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFeatureWith")) - data, err := ec.unmarshalOFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureWhereInputᚄ(ctx, v) + it.NameHasPrefix = data + case "nameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasFeatureWith = data - case "hasEntitlementplan": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementplan")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameHasSuffix = data + case "nameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEntitlementplan = data - case "hasEntitlementplanWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementplanWith")) - data, err := ec.unmarshalOEntitlementPlanWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanWhereInputᚄ(ctx, v) + it.NameEqualFold = data + case "nameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEntitlementplanWith = data - case "hasEntitlementplanfeature": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementplanfeature")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameContainsFold = data + case "displayName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayName")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEntitlementplanfeature = data - case "hasEntitlementplanfeatureWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementplanfeatureWith")) - data, err := ec.unmarshalOEntitlementPlanFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanFeatureWhereInputᚄ(ctx, v) + it.DisplayName = data + case "displayNameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEntitlementplanfeatureWith = data - case "hasPersonalAccessToken": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPersonalAccessToken")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameNEQ = data + case "displayNameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasPersonalAccessToken = data - case "hasPersonalAccessTokenWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPersonalAccessTokenWith")) - data, err := ec.unmarshalOPersonalAccessTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐPersonalAccessTokenWhereInputᚄ(ctx, v) + it.DisplayNameIn = data + case "displayNameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasPersonalAccessTokenWith = data - case "hasOauth2token": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOauth2token")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameNotIn = data + case "displayNameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOauth2token = data - case "hasOauth2tokenWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOauth2tokenWith")) - data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInputᚄ(ctx, v) + it.DisplayNameGT = data + case "displayNameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOauth2tokenWith = data - case "hasHush": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasHush")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameGTE = data + case "displayNameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasHush = data - case "hasHushWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasHushWith")) - data, err := ec.unmarshalOHushWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInputᚄ(ctx, v) + it.DisplayNameLT = data + case "displayNameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasHushWith = data - case "hasOrgmembership": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrgmembership")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameLTE = data + case "displayNameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOrgmembership = data - case "hasOrgmembershipWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrgmembershipWith")) - data, err := ec.unmarshalOOrgMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipWhereInputᚄ(ctx, v) + it.DisplayNameContains = data + case "displayNameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOrgmembershipWith = data - case "hasGroupmembership": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupmembership")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameHasPrefix = data + case "displayNameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasGroupmembership = data - case "hasGroupmembershipWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupmembershipWith")) - data, err := ec.unmarshalOGroupMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInputᚄ(ctx, v) + it.DisplayNameHasSuffix = data + case "displayNameIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasGroupmembershipWith = data - case "hasEntitlement": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlement")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameIsNil = data + case "displayNameNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasEntitlement = data - case "hasEntitlementWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntitlementWith")) - data, err := ec.unmarshalOEntitlementWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementWhereInputᚄ(ctx, v) + it.DisplayNameNotNil = data + case "displayNameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEntitlementWith = data - case "hasWebhook": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasWebhook")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameEqualFold = data + case "displayNameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasWebhook = data - case "hasWebhookWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasWebhookWith")) - data, err := ec.unmarshalOWebhookWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐWebhookWhereInputᚄ(ctx, v) + it.DisplayNameContainsFold = data + case "enabled": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("enabled")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.HasWebhookWith = data - case "hasSubscriber": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSubscriber")) + it.Enabled = data + case "enabledNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("enabledNEQ")) data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.HasSubscriber = data - case "hasSubscriberWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSubscriberWith")) - data, err := ec.unmarshalOSubscriberWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubscriberWhereInputᚄ(ctx, v) + it.EnabledNEQ = data + case "description": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasSubscriberWith = data - case "hasFile": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFile")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.Description = data + case "descriptionNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasFile = data - case "hasFileWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFileWith")) - data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) + it.DescriptionNEQ = data + case "descriptionIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasFileWith = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputFeatureHistoryWhereInput(ctx context.Context, obj interface{}) (generated.FeatureHistoryWhereInput, error) { - var it generated.FeatureHistoryWhereInput - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameIsNil", "displayNameNotNil", "displayNameEqualFold", "displayNameContainsFold", "enabled", "enabledNEQ", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "stripeFeatureID", "stripeFeatureIDNEQ", "stripeFeatureIDIn", "stripeFeatureIDNotIn", "stripeFeatureIDGT", "stripeFeatureIDGTE", "stripeFeatureIDLT", "stripeFeatureIDLTE", "stripeFeatureIDContains", "stripeFeatureIDHasPrefix", "stripeFeatureIDHasSuffix", "stripeFeatureIDIsNil", "stripeFeatureIDNotNil", "stripeFeatureIDEqualFold", "stripeFeatureIDContainsFold"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "not": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOFeatureHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureHistoryWhereInput(ctx, v) + it.DescriptionIn = data + case "descriptionNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.Not = data - case "and": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOFeatureHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureHistoryWhereInputᚄ(ctx, v) + it.DescriptionNotIn = data + case "descriptionGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.And = data - case "or": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOFeatureHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureHistoryWhereInputᚄ(ctx, v) + it.DescriptionGT = data + case "descriptionGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Or = data - case "id": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.DescriptionGTE = data + case "descriptionLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ID = data - case "idNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.DescriptionLT = data + case "descriptionLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDNEQ = data - case "idIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.DescriptionLTE = data + case "descriptionContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDIn = data - case "idNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.DescriptionContains = data + case "descriptionHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDNotIn = data - case "idGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.DescriptionHasPrefix = data + case "descriptionHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDGT = data - case "idGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.DescriptionHasSuffix = data + case "descriptionIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.IDGTE = data - case "idLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.DescriptionIsNil = data + case "descriptionNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.IDLT = data - case "idLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.DescriptionNotNil = data + case "descriptionEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDLTE = data - case "idEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.DescriptionEqualFold = data + case "descriptionContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDEqualFold = data - case "idContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.DescriptionContainsFold = data + case "stripeFeatureID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StripeFeatureID = data + case "stripeFeatureIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StripeFeatureIDNEQ = data + case "stripeFeatureIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.StripeFeatureIDIn = data + case "stripeFeatureIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.StripeFeatureIDNotIn = data + case "stripeFeatureIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StripeFeatureIDGT = data + case "stripeFeatureIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StripeFeatureIDGTE = data + case "stripeFeatureIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StripeFeatureIDLT = data + case "stripeFeatureIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StripeFeatureIDLTE = data + case "stripeFeatureIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + it.StripeFeatureIDContains = data + case "stripeFeatureIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + it.StripeFeatureIDHasPrefix = data + case "stripeFeatureIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.StripeFeatureIDHasSuffix = data + case "stripeFeatureIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.StripeFeatureIDIsNil = data + case "stripeFeatureIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + it.StripeFeatureIDNotNil = data + case "stripeFeatureIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + it.StripeFeatureIDEqualFold = data + case "stripeFeatureIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.StripeFeatureIDContainsFold = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputFeatureWhereInput(ctx context.Context, obj interface{}) (generated.FeatureWhereInput, error) { + var it generated.FeatureWhereInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameIsNil", "displayNameNotNil", "displayNameEqualFold", "displayNameContainsFold", "enabled", "enabledNEQ", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "stripeFeatureID", "stripeFeatureIDNEQ", "stripeFeatureIDIn", "stripeFeatureIDNotIn", "stripeFeatureIDGT", "stripeFeatureIDGTE", "stripeFeatureIDLT", "stripeFeatureIDLTE", "stripeFeatureIDContains", "stripeFeatureIDHasPrefix", "stripeFeatureIDHasSuffix", "stripeFeatureIDIsNil", "stripeFeatureIDNotNil", "stripeFeatureIDEqualFold", "stripeFeatureIDContainsFold", "hasOwner", "hasOwnerWith", "hasPlans", "hasPlansWith", "hasEvents", "hasEventsWith", "hasFeatures", "hasFeaturesWith"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) + data, err := ec.unmarshalOFeatureWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureWhereInput(ctx, v) if err != nil { return it, err } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Not = data + case "and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) + data, err := ec.unmarshalOFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.And = data + case "or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) + data, err := ec.unmarshalOFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Or = data + case "id": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ID = data + case "idNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.IDNEQ = data + case "idIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.IDIn = data + case "idNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDNotIn = data + case "idGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDGT = data + case "idGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOFeatureHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + it.IDGTE = data + case "idLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOFeatureHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + it.IDLT = data + case "idLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOFeatureHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + it.IDLTE = data + case "idEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOFeatureHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + it.IDEqualFold = data + case "idContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.OperationNotIn = data + it.IDContainsFold = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -274845,77 +281664,77 @@ func (ec *executionContext) unmarshalInputFeatureHistoryWhereInput(ctx context.C it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -274936,14 +281755,14 @@ func (ec *executionContext) unmarshalInputFeatureHistoryWhereInput(ctx context.C it.OwnerIDNotNil = data case "ownerIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDEqualFold = data case "ownerIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -275368,20 +282187,76 @@ func (ec *executionContext) unmarshalInputFeatureHistoryWhereInput(ctx context.C return it, err } it.StripeFeatureIDContainsFold = data + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOwnerWith = data + case "hasPlans": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPlans")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasPlans = data + case "hasPlansWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPlansWith")) + data, err := ec.unmarshalOEntitlementPlanWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasPlansWith = data + case "hasEvents": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEvents = data + case "hasEventsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) + data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEventsWith = data + case "hasFeatures": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFeatures")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasFeatures = data + case "hasFeaturesWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFeaturesWith")) + data, err := ec.unmarshalOEntitlementPlanFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanFeatureWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasFeaturesWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputFeatureWhereInput(ctx context.Context, obj interface{}) (generated.FeatureWhereInput, error) { - var it generated.FeatureWhereInput +func (ec *executionContext) unmarshalInputFileHistoryWhereInput(ctx context.Context, obj interface{}) (generated.FileHistoryWhereInput, error) { + var it generated.FileHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameIsNil", "displayNameNotNil", "displayNameEqualFold", "displayNameContainsFold", "enabled", "enabledNEQ", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "stripeFeatureID", "stripeFeatureIDNEQ", "stripeFeatureIDIn", "stripeFeatureIDNotIn", "stripeFeatureIDGT", "stripeFeatureIDGTE", "stripeFeatureIDLT", "stripeFeatureIDLTE", "stripeFeatureIDContains", "stripeFeatureIDHasPrefix", "stripeFeatureIDHasSuffix", "stripeFeatureIDIsNil", "stripeFeatureIDNotNil", "stripeFeatureIDEqualFold", "stripeFeatureIDContainsFold", "hasOwner", "hasOwnerWith", "hasPlans", "hasPlansWith", "hasEvents", "hasEventsWith", "hasFeatures", "hasFeaturesWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "providedFileName", "providedFileNameNEQ", "providedFileNameIn", "providedFileNameNotIn", "providedFileNameGT", "providedFileNameGTE", "providedFileNameLT", "providedFileNameLTE", "providedFileNameContains", "providedFileNameHasPrefix", "providedFileNameHasSuffix", "providedFileNameEqualFold", "providedFileNameContainsFold", "providedFileExtension", "providedFileExtensionNEQ", "providedFileExtensionIn", "providedFileExtensionNotIn", "providedFileExtensionGT", "providedFileExtensionGTE", "providedFileExtensionLT", "providedFileExtensionLTE", "providedFileExtensionContains", "providedFileExtensionHasPrefix", "providedFileExtensionHasSuffix", "providedFileExtensionEqualFold", "providedFileExtensionContainsFold", "providedFileSize", "providedFileSizeNEQ", "providedFileSizeIn", "providedFileSizeNotIn", "providedFileSizeGT", "providedFileSizeGTE", "providedFileSizeLT", "providedFileSizeLTE", "providedFileSizeIsNil", "providedFileSizeNotNil", "persistedFileSize", "persistedFileSizeNEQ", "persistedFileSizeIn", "persistedFileSizeNotIn", "persistedFileSizeGT", "persistedFileSizeGTE", "persistedFileSizeLT", "persistedFileSizeLTE", "persistedFileSizeIsNil", "persistedFileSizeNotNil", "detectedMimeType", "detectedMimeTypeNEQ", "detectedMimeTypeIn", "detectedMimeTypeNotIn", "detectedMimeTypeGT", "detectedMimeTypeGTE", "detectedMimeTypeLT", "detectedMimeTypeLTE", "detectedMimeTypeContains", "detectedMimeTypeHasPrefix", "detectedMimeTypeHasSuffix", "detectedMimeTypeIsNil", "detectedMimeTypeNotNil", "detectedMimeTypeEqualFold", "detectedMimeTypeContainsFold", "md5Hash", "md5HashNEQ", "md5HashIn", "md5HashNotIn", "md5HashGT", "md5HashGTE", "md5HashLT", "md5HashLTE", "md5HashContains", "md5HashHasPrefix", "md5HashHasSuffix", "md5HashIsNil", "md5HashNotNil", "md5HashEqualFold", "md5HashContainsFold", "detectedContentType", "detectedContentTypeNEQ", "detectedContentTypeIn", "detectedContentTypeNotIn", "detectedContentTypeGT", "detectedContentTypeGTE", "detectedContentTypeLT", "detectedContentTypeLTE", "detectedContentTypeContains", "detectedContentTypeHasPrefix", "detectedContentTypeHasSuffix", "detectedContentTypeEqualFold", "detectedContentTypeContainsFold", "storeKey", "storeKeyNEQ", "storeKeyIn", "storeKeyNotIn", "storeKeyGT", "storeKeyGTE", "storeKeyLT", "storeKeyLTE", "storeKeyContains", "storeKeyHasPrefix", "storeKeyHasSuffix", "storeKeyIsNil", "storeKeyNotNil", "storeKeyEqualFold", "storeKeyContainsFold", "categoryType", "categoryTypeNEQ", "categoryTypeIn", "categoryTypeNotIn", "categoryTypeGT", "categoryTypeGTE", "categoryTypeLT", "categoryTypeLTE", "categoryTypeContains", "categoryTypeHasPrefix", "categoryTypeHasSuffix", "categoryTypeIsNil", "categoryTypeNotNil", "categoryTypeEqualFold", "categoryTypeContainsFold", "uri", "uriNEQ", "uriIn", "uriNotIn", "uriGT", "uriGTE", "uriLT", "uriLTE", "uriContains", "uriHasPrefix", "uriHasSuffix", "uriIsNil", "uriNotNil", "uriEqualFold", "uriContainsFold", "storageScheme", "storageSchemeNEQ", "storageSchemeIn", "storageSchemeNotIn", "storageSchemeGT", "storageSchemeGTE", "storageSchemeLT", "storageSchemeLTE", "storageSchemeContains", "storageSchemeHasPrefix", "storageSchemeHasSuffix", "storageSchemeIsNil", "storageSchemeNotNil", "storageSchemeEqualFold", "storageSchemeContainsFold", "storageVolume", "storageVolumeNEQ", "storageVolumeIn", "storageVolumeNotIn", "storageVolumeGT", "storageVolumeGTE", "storageVolumeLT", "storageVolumeLTE", "storageVolumeContains", "storageVolumeHasPrefix", "storageVolumeHasSuffix", "storageVolumeIsNil", "storageVolumeNotNil", "storageVolumeEqualFold", "storageVolumeContainsFold", "storagePath", "storagePathNEQ", "storagePathIn", "storagePathNotIn", "storagePathGT", "storagePathGTE", "storagePathLT", "storagePathLTE", "storagePathContains", "storagePathHasPrefix", "storagePathHasSuffix", "storagePathIsNil", "storagePathNotNil", "storagePathEqualFold", "storagePathContainsFold"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -275390,21 +282265,21 @@ func (ec *executionContext) unmarshalInputFeatureWhereInput(ctx context.Context, switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOFeatureWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureWhereInput(ctx, v) + data, err := ec.unmarshalOFileHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOFileHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFeatureWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOFileHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -275479,6 +282354,195 @@ func (ec *executionContext) unmarshalInputFeatureWhereInput(ctx context.Context, return it, err } it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOFileHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOFileHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOFileHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOFileHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -275499,1106 +282563,1778 @@ func (ec *executionContext) unmarshalInputFeatureWhereInput(ctx context.Context, if err != nil { return it, err } - it.CreatedAtIn = data - case "createdAtNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.CreatedAtIn = data + case "createdAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtNotIn = data + case "createdAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtGT = data + case "createdAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtGTE = data + case "createdAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtLT = data + case "createdAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtLTE = data + case "createdAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtIsNil = data + case "createdAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.CreatedAtNotNil = data + case "updatedAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAt = data + case "updatedAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtNEQ = data + case "updatedAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtIn = data + case "updatedAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtNotIn = data + case "updatedAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtGT = data + case "updatedAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtGTE = data + case "updatedAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtLT = data + case "updatedAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtLTE = data + case "updatedAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtIsNil = data + case "updatedAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.UpdatedAtNotNil = data + case "createdBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedBy = data + case "createdByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByNEQ = data + case "createdByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.CreatedByIn = data + case "createdByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.CreatedByNotIn = data + case "createdByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByGT = data + case "createdByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByGTE = data + case "createdByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByLT = data + case "createdByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByLTE = data + case "createdByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByContains = data + case "createdByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByHasPrefix = data + case "createdByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByHasSuffix = data + case "createdByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.CreatedByIsNil = data + case "createdByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.CreatedByNotNil = data + case "createdByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByEqualFold = data + case "createdByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CreatedByContainsFold = data + case "updatedBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedBy = data + case "updatedByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByNEQ = data + case "updatedByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByIn = data + case "updatedByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByNotIn = data + case "updatedByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByGT = data + case "updatedByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByGTE = data + case "updatedByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByLT = data + case "updatedByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByLTE = data + case "updatedByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByContains = data + case "updatedByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByHasPrefix = data + case "updatedByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByHasSuffix = data + case "updatedByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByIsNil = data + case "updatedByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByNotNil = data + case "updatedByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByEqualFold = data + case "updatedByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.UpdatedByContainsFold = data + case "deletedAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.DeletedAt = data + case "deletedAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.DeletedAtNEQ = data + case "deletedAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.DeletedAtIn = data + case "deletedAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.DeletedAtNotIn = data + case "deletedAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.DeletedAtGT = data + case "deletedAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.DeletedAtGTE = data + case "deletedAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.DeletedAtLT = data + case "deletedAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.DeletedAtLTE = data + case "deletedAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.DeletedAtIsNil = data + case "deletedAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.DeletedAtNotNil = data + case "deletedBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedBy")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedBy = data + case "deletedByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByNEQ = data + case "deletedByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.DeletedByIn = data + case "deletedByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.DeletedByNotIn = data + case "deletedByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByGT = data + case "deletedByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByGTE = data + case "deletedByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByLT = data + case "deletedByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByLTE = data + case "deletedByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByContains = data + case "deletedByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByHasPrefix = data + case "deletedByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByHasSuffix = data + case "deletedByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.DeletedByIsNil = data + case "deletedByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.DeletedByNotNil = data + case "deletedByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByEqualFold = data + case "deletedByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DeletedByContainsFold = data + case "providedFileName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileName")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileName = data + case "providedFileNameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameNEQ = data + case "providedFileNameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameIn = data + case "providedFileNameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameNotIn = data + case "providedFileNameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameGT = data + case "providedFileNameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameGTE = data + case "providedFileNameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameLT = data + case "providedFileNameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameLTE = data + case "providedFileNameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameContains = data + case "providedFileNameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameHasPrefix = data + case "providedFileNameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameHasSuffix = data + case "providedFileNameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameEqualFold = data + case "providedFileNameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileNameContainsFold = data + case "providedFileExtension": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtension")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtension = data + case "providedFileExtensionNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionNEQ = data + case "providedFileExtensionIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionIn = data + case "providedFileExtensionNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionNotIn = data + case "providedFileExtensionGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionGT = data + case "providedFileExtensionGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionGTE = data + case "providedFileExtensionLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionLT = data + case "providedFileExtensionLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionLTE = data + case "providedFileExtensionContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionContains = data + case "providedFileExtensionHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionHasPrefix = data + case "providedFileExtensionHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionHasSuffix = data + case "providedFileExtensionEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionEqualFold = data + case "providedFileExtensionContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileExtensionContainsFold = data + case "providedFileSize": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSize")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileSize = data + case "providedFileSizeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeNEQ")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileSizeNEQ = data + case "providedFileSizeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeIn")) + data, err := ec.unmarshalOInt2ᚕint64ᚄ(ctx, v) + if err != nil { + return it, err + } + it.ProvidedFileSizeIn = data + case "providedFileSizeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeNotIn")) + data, err := ec.unmarshalOInt2ᚕint64ᚄ(ctx, v) if err != nil { return it, err } - it.CreatedAtNotIn = data - case "createdAtGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.ProvidedFileSizeNotIn = data + case "providedFileSizeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeGT")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.CreatedAtGT = data - case "createdAtGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.ProvidedFileSizeGT = data + case "providedFileSizeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeGTE")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.CreatedAtGTE = data - case "createdAtLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.ProvidedFileSizeGTE = data + case "providedFileSizeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeLT")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.CreatedAtLT = data - case "createdAtLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.ProvidedFileSizeLT = data + case "providedFileSizeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeLTE")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.CreatedAtLTE = data - case "createdAtIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIsNil")) + it.ProvidedFileSizeLTE = data + case "providedFileSizeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CreatedAtIsNil = data - case "createdAtNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotNil")) + it.ProvidedFileSizeIsNil = data + case "providedFileSizeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CreatedAtNotNil = data - case "updatedAt": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.ProvidedFileSizeNotNil = data + case "persistedFileSize": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSize")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.UpdatedAt = data - case "updatedAtNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PersistedFileSize = data + case "persistedFileSizeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeNEQ")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.UpdatedAtNEQ = data - case "updatedAtIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.PersistedFileSizeNEQ = data + case "persistedFileSizeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeIn")) + data, err := ec.unmarshalOInt2ᚕint64ᚄ(ctx, v) if err != nil { return it, err } - it.UpdatedAtIn = data - case "updatedAtNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.PersistedFileSizeIn = data + case "persistedFileSizeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeNotIn")) + data, err := ec.unmarshalOInt2ᚕint64ᚄ(ctx, v) if err != nil { return it, err } - it.UpdatedAtNotIn = data - case "updatedAtGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PersistedFileSizeNotIn = data + case "persistedFileSizeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeGT")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.UpdatedAtGT = data - case "updatedAtGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PersistedFileSizeGT = data + case "persistedFileSizeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeGTE")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.UpdatedAtGTE = data - case "updatedAtLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PersistedFileSizeGTE = data + case "persistedFileSizeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeLT")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.UpdatedAtLT = data - case "updatedAtLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PersistedFileSizeLT = data + case "persistedFileSizeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeLTE")) + data, err := ec.unmarshalOInt2ᚖint64(ctx, v) if err != nil { return it, err } - it.UpdatedAtLTE = data - case "updatedAtIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIsNil")) + it.PersistedFileSizeLTE = data + case "persistedFileSizeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.UpdatedAtIsNil = data - case "updatedAtNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotNil")) + it.PersistedFileSizeIsNil = data + case "persistedFileSizeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.UpdatedAtNotNil = data - case "createdBy": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy")) + it.PersistedFileSizeNotNil = data + case "detectedMimeType": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeType")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedBy = data - case "createdByNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNEQ")) + it.DetectedMimeType = data + case "detectedMimeTypeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByNEQ = data - case "createdByIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIn")) + it.DetectedMimeTypeNEQ = data + case "detectedMimeTypeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CreatedByIn = data - case "createdByNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotIn")) + it.DetectedMimeTypeIn = data + case "detectedMimeTypeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CreatedByNotIn = data - case "createdByGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGT")) + it.DetectedMimeTypeNotIn = data + case "detectedMimeTypeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByGT = data - case "createdByGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGTE")) + it.DetectedMimeTypeGT = data + case "detectedMimeTypeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByGTE = data - case "createdByLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLT")) + it.DetectedMimeTypeGTE = data + case "detectedMimeTypeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByLT = data - case "createdByLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLTE")) + it.DetectedMimeTypeLT = data + case "detectedMimeTypeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByLTE = data - case "createdByContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContains")) + it.DetectedMimeTypeLTE = data + case "detectedMimeTypeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByContains = data - case "createdByHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasPrefix")) + it.DetectedMimeTypeContains = data + case "detectedMimeTypeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByHasPrefix = data - case "createdByHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasSuffix")) + it.DetectedMimeTypeHasPrefix = data + case "detectedMimeTypeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByHasSuffix = data - case "createdByIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIsNil")) + it.DetectedMimeTypeHasSuffix = data + case "detectedMimeTypeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CreatedByIsNil = data - case "createdByNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotNil")) + it.DetectedMimeTypeIsNil = data + case "detectedMimeTypeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CreatedByNotNil = data - case "createdByEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByEqualFold")) + it.DetectedMimeTypeNotNil = data + case "detectedMimeTypeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByEqualFold = data - case "createdByContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContainsFold")) + it.DetectedMimeTypeEqualFold = data + case "detectedMimeTypeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByContainsFold = data - case "updatedBy": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy")) + it.DetectedMimeTypeContainsFold = data + case "md5Hash": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5Hash")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedBy = data - case "updatedByNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNEQ")) + it.Md5Hash = data + case "md5HashNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByNEQ = data - case "updatedByIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIn")) + it.Md5HashNEQ = data + case "md5HashIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.UpdatedByIn = data - case "updatedByNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotIn")) + it.Md5HashIn = data + case "md5HashNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.UpdatedByNotIn = data - case "updatedByGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGT")) + it.Md5HashNotIn = data + case "md5HashGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByGT = data - case "updatedByGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGTE")) + it.Md5HashGT = data + case "md5HashGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByGTE = data - case "updatedByLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLT")) + it.Md5HashGTE = data + case "md5HashLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByLT = data - case "updatedByLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLTE")) + it.Md5HashLT = data + case "md5HashLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByLTE = data - case "updatedByContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContains")) + it.Md5HashLTE = data + case "md5HashContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByContains = data - case "updatedByHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasPrefix")) + it.Md5HashContains = data + case "md5HashHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByHasPrefix = data - case "updatedByHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasSuffix")) + it.Md5HashHasPrefix = data + case "md5HashHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByHasSuffix = data - case "updatedByIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIsNil")) + it.Md5HashHasSuffix = data + case "md5HashIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.UpdatedByIsNil = data - case "updatedByNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotNil")) + it.Md5HashIsNil = data + case "md5HashNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.UpdatedByNotNil = data - case "updatedByEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByEqualFold")) + it.Md5HashNotNil = data + case "md5HashEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByEqualFold = data - case "updatedByContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContainsFold")) + it.Md5HashEqualFold = data + case "md5HashContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByContainsFold = data - case "deletedAt": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAt")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.Md5HashContainsFold = data + case "detectedContentType": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentType")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAt = data - case "deletedAtNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.DetectedContentType = data + case "detectedContentTypeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtNEQ = data - case "deletedAtIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.DetectedContentTypeNEQ = data + case "detectedContentTypeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DeletedAtIn = data - case "deletedAtNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.DetectedContentTypeIn = data + case "detectedContentTypeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DeletedAtNotIn = data - case "deletedAtGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.DetectedContentTypeNotIn = data + case "detectedContentTypeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtGT = data - case "deletedAtGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.DetectedContentTypeGT = data + case "detectedContentTypeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtGTE = data - case "deletedAtLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.DetectedContentTypeGTE = data + case "detectedContentTypeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtLT = data - case "deletedAtLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.DetectedContentTypeLT = data + case "detectedContentTypeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtLTE = data - case "deletedAtIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.DetectedContentTypeLTE = data + case "detectedContentTypeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtIsNil = data - case "deletedAtNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.DetectedContentTypeContains = data + case "detectedContentTypeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtNotNil = data - case "deletedBy": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedBy")) + it.DetectedContentTypeHasPrefix = data + case "detectedContentTypeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedBy = data - case "deletedByNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNEQ")) + it.DetectedContentTypeHasSuffix = data + case "detectedContentTypeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByNEQ = data - case "deletedByIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIn")) + it.DetectedContentTypeEqualFold = data + case "detectedContentTypeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DetectedContentTypeContainsFold = data + case "storeKey": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKey")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StoreKey = data + case "storeKeyNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StoreKeyNEQ = data + case "storeKeyIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DeletedByIn = data - case "deletedByNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotIn")) + it.StoreKeyIn = data + case "storeKeyNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DeletedByNotIn = data - case "deletedByGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGT")) + it.StoreKeyNotIn = data + case "storeKeyGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByGT = data - case "deletedByGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGTE")) + it.StoreKeyGT = data + case "storeKeyGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByGTE = data - case "deletedByLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLT")) + it.StoreKeyGTE = data + case "storeKeyLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByLT = data - case "deletedByLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLTE")) + it.StoreKeyLT = data + case "storeKeyLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByLTE = data - case "deletedByContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContains")) + it.StoreKeyLTE = data + case "storeKeyContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByContains = data - case "deletedByHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasPrefix")) + it.StoreKeyContains = data + case "storeKeyHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByHasPrefix = data - case "deletedByHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasSuffix")) + it.StoreKeyHasPrefix = data + case "storeKeyHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByHasSuffix = data - case "deletedByIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIsNil")) + it.StoreKeyHasSuffix = data + case "storeKeyIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DeletedByIsNil = data - case "deletedByNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotNil")) + it.StoreKeyIsNil = data + case "storeKeyNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DeletedByNotNil = data - case "deletedByEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByEqualFold")) + it.StoreKeyNotNil = data + case "storeKeyEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByEqualFold = data - case "deletedByContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContainsFold")) + it.StoreKeyEqualFold = data + case "storeKeyContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByContainsFold = data - case "ownerID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.StoreKeyContainsFold = data + case "categoryType": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryType")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerID = data - case "ownerIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryType = data + case "categoryTypeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDNEQ = data - case "ownerIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.CategoryTypeNEQ = data + case "categoryTypeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.OwnerIDIn = data - case "ownerIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.CategoryTypeIn = data + case "categoryTypeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.OwnerIDNotIn = data - case "ownerIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryTypeNotIn = data + case "categoryTypeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDGT = data - case "ownerIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryTypeGT = data + case "categoryTypeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDGTE = data - case "ownerIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryTypeGTE = data + case "categoryTypeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDLT = data - case "ownerIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryTypeLT = data + case "categoryTypeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDLTE = data - case "ownerIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryTypeLTE = data + case "categoryTypeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDContains = data - case "ownerIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryTypeContains = data + case "categoryTypeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDHasPrefix = data - case "ownerIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryTypeHasPrefix = data + case "categoryTypeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDHasSuffix = data - case "ownerIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) + it.CategoryTypeHasSuffix = data + case "categoryTypeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.OwnerIDIsNil = data - case "ownerIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) + it.CategoryTypeIsNil = data + case "categoryTypeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.OwnerIDNotNil = data - case "ownerIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryTypeNotNil = data + case "categoryTypeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDEqualFold = data - case "ownerIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.CategoryTypeEqualFold = data + case "categoryTypeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OwnerIDContainsFold = data - case "name": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + it.CategoryTypeContainsFold = data + case "uri": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uri")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Name = data - case "nameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) + it.URI = data + case "uriNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameNEQ = data - case "nameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) + it.URINEQ = data + case "uriIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.NameIn = data - case "nameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) + it.URIIn = data + case "uriNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.NameNotIn = data - case "nameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) + it.URINotIn = data + case "uriGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameGT = data - case "nameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) + it.URIGT = data + case "uriGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameGTE = data - case "nameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) + it.URIGTE = data + case "uriLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameLT = data - case "nameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) + it.URILT = data + case "uriLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameLTE = data - case "nameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) + it.URILTE = data + case "uriContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameContains = data - case "nameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) + it.URIContains = data + case "uriHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameHasPrefix = data - case "nameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) + it.URIHasPrefix = data + case "uriHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameHasSuffix = data - case "nameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) + it.URIHasSuffix = data + case "uriIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.URIIsNil = data + case "uriNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.URINotNil = data + case "uriEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameEqualFold = data - case "nameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) + it.URIEqualFold = data + case "uriContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameContainsFold = data - case "displayName": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayName")) + it.URIContainsFold = data + case "storageScheme": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageScheme")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayName = data - case "displayNameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNEQ")) + it.StorageScheme = data + case "storageSchemeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameNEQ = data - case "displayNameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIn")) + it.StorageSchemeNEQ = data + case "storageSchemeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DisplayNameIn = data - case "displayNameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotIn")) + it.StorageSchemeIn = data + case "storageSchemeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DisplayNameNotIn = data - case "displayNameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGT")) + it.StorageSchemeNotIn = data + case "storageSchemeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameGT = data - case "displayNameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGTE")) + it.StorageSchemeGT = data + case "storageSchemeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameGTE = data - case "displayNameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLT")) + it.StorageSchemeGTE = data + case "storageSchemeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameLT = data - case "displayNameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLTE")) + it.StorageSchemeLT = data + case "storageSchemeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameLTE = data - case "displayNameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContains")) + it.StorageSchemeLTE = data + case "storageSchemeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameContains = data - case "displayNameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasPrefix")) + it.StorageSchemeContains = data + case "storageSchemeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameHasPrefix = data - case "displayNameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasSuffix")) + it.StorageSchemeHasPrefix = data + case "storageSchemeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameHasSuffix = data - case "displayNameIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIsNil")) + it.StorageSchemeHasSuffix = data + case "storageSchemeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DisplayNameIsNil = data - case "displayNameNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotNil")) + it.StorageSchemeIsNil = data + case "storageSchemeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DisplayNameNotNil = data - case "displayNameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameEqualFold")) + it.StorageSchemeNotNil = data + case "storageSchemeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameEqualFold = data - case "displayNameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContainsFold")) + it.StorageSchemeEqualFold = data + case "storageSchemeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameContainsFold = data - case "enabled": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("enabled")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.Enabled = data - case "enabledNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("enabledNEQ")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.EnabledNEQ = data - case "description": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description")) + it.StorageSchemeContainsFold = data + case "storageVolume": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolume")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Description = data - case "descriptionNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNEQ")) + it.StorageVolume = data + case "storageVolumeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionNEQ = data - case "descriptionIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIn")) + it.StorageVolumeNEQ = data + case "storageVolumeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DescriptionIn = data - case "descriptionNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotIn")) + it.StorageVolumeIn = data + case "storageVolumeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DescriptionNotIn = data - case "descriptionGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGT")) + it.StorageVolumeNotIn = data + case "storageVolumeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionGT = data - case "descriptionGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGTE")) + it.StorageVolumeGT = data + case "storageVolumeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionGTE = data - case "descriptionLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLT")) + it.StorageVolumeGTE = data + case "storageVolumeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionLT = data - case "descriptionLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLTE")) + it.StorageVolumeLT = data + case "storageVolumeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionLTE = data - case "descriptionContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContains")) + it.StorageVolumeLTE = data + case "storageVolumeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionContains = data - case "descriptionHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasPrefix")) + it.StorageVolumeContains = data + case "storageVolumeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionHasPrefix = data - case "descriptionHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasSuffix")) + it.StorageVolumeHasPrefix = data + case "storageVolumeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionHasSuffix = data - case "descriptionIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIsNil")) + it.StorageVolumeHasSuffix = data + case "storageVolumeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DescriptionIsNil = data - case "descriptionNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotNil")) + it.StorageVolumeIsNil = data + case "storageVolumeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DescriptionNotNil = data - case "descriptionEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionEqualFold")) + it.StorageVolumeNotNil = data + case "storageVolumeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionEqualFold = data - case "descriptionContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContainsFold")) + it.StorageVolumeEqualFold = data + case "storageVolumeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionContainsFold = data - case "stripeFeatureID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureID")) + it.StorageVolumeContainsFold = data + case "storagePath": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePath")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StripeFeatureID = data - case "stripeFeatureIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDNEQ")) + it.StoragePath = data + case "storagePathNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StripeFeatureIDNEQ = data - case "stripeFeatureIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDIn")) + it.StoragePathNEQ = data + case "storagePathIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.StripeFeatureIDIn = data - case "stripeFeatureIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDNotIn")) + it.StoragePathIn = data + case "storagePathNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.StripeFeatureIDNotIn = data - case "stripeFeatureIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StripeFeatureIDGT = data - case "stripeFeatureIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StripeFeatureIDGTE = data - case "stripeFeatureIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StripeFeatureIDLT = data - case "stripeFeatureIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDLTE")) + it.StoragePathNotIn = data + case "storagePathGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StripeFeatureIDLTE = data - case "stripeFeatureIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDContains")) + it.StoragePathGT = data + case "storagePathGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StripeFeatureIDContains = data - case "stripeFeatureIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDHasPrefix")) + it.StoragePathGTE = data + case "storagePathLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StripeFeatureIDHasPrefix = data - case "stripeFeatureIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDHasSuffix")) + it.StoragePathLT = data + case "storagePathLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StripeFeatureIDHasSuffix = data - case "stripeFeatureIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StripeFeatureIDIsNil = data - case "stripeFeatureIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StripeFeatureIDNotNil = data - case "stripeFeatureIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDEqualFold")) + it.StoragePathLTE = data + case "storagePathContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StripeFeatureIDEqualFold = data - case "stripeFeatureIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeFeatureIDContainsFold")) + it.StoragePathContains = data + case "storagePathHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { - return it, err - } - it.StripeFeatureIDContainsFold = data - case "hasOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasOwner = data - case "hasOwnerWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasOwnerWith = data - case "hasPlans": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPlans")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasPlans = data - case "hasPlansWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPlansWith")) - data, err := ec.unmarshalOEntitlementPlanWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanWhereInputᚄ(ctx, v) + return it, err + } + it.StoragePathHasPrefix = data + case "storagePathHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasPlansWith = data - case "hasEvents": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.StoragePathHasSuffix = data + case "storagePathIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasEvents = data - case "hasEventsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) - data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + it.StoragePathIsNil = data + case "storagePathNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasEventsWith = data - case "hasFeatures": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFeatures")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.StoragePathNotNil = data + case "storagePathEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasFeatures = data - case "hasFeaturesWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFeaturesWith")) - data, err := ec.unmarshalOEntitlementPlanFeatureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntitlementPlanFeatureWhereInputᚄ(ctx, v) + it.StoragePathEqualFold = data + case "storagePathContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasFeaturesWith = data + it.StoragePathContainsFold = data } } return it, nil } -func (ec *executionContext) unmarshalInputFileHistoryWhereInput(ctx context.Context, obj interface{}) (generated.FileHistoryWhereInput, error) { - var it generated.FileHistoryWhereInput +func (ec *executionContext) unmarshalInputFileWhereInput(ctx context.Context, obj interface{}) (generated.FileWhereInput, error) { + var it generated.FileWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "providedFileName", "providedFileNameNEQ", "providedFileNameIn", "providedFileNameNotIn", "providedFileNameGT", "providedFileNameGTE", "providedFileNameLT", "providedFileNameLTE", "providedFileNameContains", "providedFileNameHasPrefix", "providedFileNameHasSuffix", "providedFileNameEqualFold", "providedFileNameContainsFold", "providedFileExtension", "providedFileExtensionNEQ", "providedFileExtensionIn", "providedFileExtensionNotIn", "providedFileExtensionGT", "providedFileExtensionGTE", "providedFileExtensionLT", "providedFileExtensionLTE", "providedFileExtensionContains", "providedFileExtensionHasPrefix", "providedFileExtensionHasSuffix", "providedFileExtensionEqualFold", "providedFileExtensionContainsFold", "providedFileSize", "providedFileSizeNEQ", "providedFileSizeIn", "providedFileSizeNotIn", "providedFileSizeGT", "providedFileSizeGTE", "providedFileSizeLT", "providedFileSizeLTE", "providedFileSizeIsNil", "providedFileSizeNotNil", "persistedFileSize", "persistedFileSizeNEQ", "persistedFileSizeIn", "persistedFileSizeNotIn", "persistedFileSizeGT", "persistedFileSizeGTE", "persistedFileSizeLT", "persistedFileSizeLTE", "persistedFileSizeIsNil", "persistedFileSizeNotNil", "detectedMimeType", "detectedMimeTypeNEQ", "detectedMimeTypeIn", "detectedMimeTypeNotIn", "detectedMimeTypeGT", "detectedMimeTypeGTE", "detectedMimeTypeLT", "detectedMimeTypeLTE", "detectedMimeTypeContains", "detectedMimeTypeHasPrefix", "detectedMimeTypeHasSuffix", "detectedMimeTypeIsNil", "detectedMimeTypeNotNil", "detectedMimeTypeEqualFold", "detectedMimeTypeContainsFold", "md5Hash", "md5HashNEQ", "md5HashIn", "md5HashNotIn", "md5HashGT", "md5HashGTE", "md5HashLT", "md5HashLTE", "md5HashContains", "md5HashHasPrefix", "md5HashHasSuffix", "md5HashIsNil", "md5HashNotNil", "md5HashEqualFold", "md5HashContainsFold", "detectedContentType", "detectedContentTypeNEQ", "detectedContentTypeIn", "detectedContentTypeNotIn", "detectedContentTypeGT", "detectedContentTypeGTE", "detectedContentTypeLT", "detectedContentTypeLTE", "detectedContentTypeContains", "detectedContentTypeHasPrefix", "detectedContentTypeHasSuffix", "detectedContentTypeEqualFold", "detectedContentTypeContainsFold", "storeKey", "storeKeyNEQ", "storeKeyIn", "storeKeyNotIn", "storeKeyGT", "storeKeyGTE", "storeKeyLT", "storeKeyLTE", "storeKeyContains", "storeKeyHasPrefix", "storeKeyHasSuffix", "storeKeyIsNil", "storeKeyNotNil", "storeKeyEqualFold", "storeKeyContainsFold", "categoryType", "categoryTypeNEQ", "categoryTypeIn", "categoryTypeNotIn", "categoryTypeGT", "categoryTypeGTE", "categoryTypeLT", "categoryTypeLTE", "categoryTypeContains", "categoryTypeHasPrefix", "categoryTypeHasSuffix", "categoryTypeIsNil", "categoryTypeNotNil", "categoryTypeEqualFold", "categoryTypeContainsFold", "uri", "uriNEQ", "uriIn", "uriNotIn", "uriGT", "uriGTE", "uriLT", "uriLTE", "uriContains", "uriHasPrefix", "uriHasSuffix", "uriIsNil", "uriNotNil", "uriEqualFold", "uriContainsFold", "storageScheme", "storageSchemeNEQ", "storageSchemeIn", "storageSchemeNotIn", "storageSchemeGT", "storageSchemeGTE", "storageSchemeLT", "storageSchemeLTE", "storageSchemeContains", "storageSchemeHasPrefix", "storageSchemeHasSuffix", "storageSchemeIsNil", "storageSchemeNotNil", "storageSchemeEqualFold", "storageSchemeContainsFold", "storageVolume", "storageVolumeNEQ", "storageVolumeIn", "storageVolumeNotIn", "storageVolumeGT", "storageVolumeGTE", "storageVolumeLT", "storageVolumeLTE", "storageVolumeContains", "storageVolumeHasPrefix", "storageVolumeHasSuffix", "storageVolumeIsNil", "storageVolumeNotNil", "storageVolumeEqualFold", "storageVolumeContainsFold", "storagePath", "storagePathNEQ", "storagePathIn", "storagePathNotIn", "storagePathGT", "storagePathGTE", "storagePathLT", "storagePathLTE", "storagePathContains", "storagePathHasPrefix", "storagePathHasSuffix", "storagePathIsNil", "storagePathNotNil", "storagePathEqualFold", "storagePathContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "providedFileName", "providedFileNameNEQ", "providedFileNameIn", "providedFileNameNotIn", "providedFileNameGT", "providedFileNameGTE", "providedFileNameLT", "providedFileNameLTE", "providedFileNameContains", "providedFileNameHasPrefix", "providedFileNameHasSuffix", "providedFileNameEqualFold", "providedFileNameContainsFold", "providedFileExtension", "providedFileExtensionNEQ", "providedFileExtensionIn", "providedFileExtensionNotIn", "providedFileExtensionGT", "providedFileExtensionGTE", "providedFileExtensionLT", "providedFileExtensionLTE", "providedFileExtensionContains", "providedFileExtensionHasPrefix", "providedFileExtensionHasSuffix", "providedFileExtensionEqualFold", "providedFileExtensionContainsFold", "providedFileSize", "providedFileSizeNEQ", "providedFileSizeIn", "providedFileSizeNotIn", "providedFileSizeGT", "providedFileSizeGTE", "providedFileSizeLT", "providedFileSizeLTE", "providedFileSizeIsNil", "providedFileSizeNotNil", "persistedFileSize", "persistedFileSizeNEQ", "persistedFileSizeIn", "persistedFileSizeNotIn", "persistedFileSizeGT", "persistedFileSizeGTE", "persistedFileSizeLT", "persistedFileSizeLTE", "persistedFileSizeIsNil", "persistedFileSizeNotNil", "detectedMimeType", "detectedMimeTypeNEQ", "detectedMimeTypeIn", "detectedMimeTypeNotIn", "detectedMimeTypeGT", "detectedMimeTypeGTE", "detectedMimeTypeLT", "detectedMimeTypeLTE", "detectedMimeTypeContains", "detectedMimeTypeHasPrefix", "detectedMimeTypeHasSuffix", "detectedMimeTypeIsNil", "detectedMimeTypeNotNil", "detectedMimeTypeEqualFold", "detectedMimeTypeContainsFold", "md5Hash", "md5HashNEQ", "md5HashIn", "md5HashNotIn", "md5HashGT", "md5HashGTE", "md5HashLT", "md5HashLTE", "md5HashContains", "md5HashHasPrefix", "md5HashHasSuffix", "md5HashIsNil", "md5HashNotNil", "md5HashEqualFold", "md5HashContainsFold", "detectedContentType", "detectedContentTypeNEQ", "detectedContentTypeIn", "detectedContentTypeNotIn", "detectedContentTypeGT", "detectedContentTypeGTE", "detectedContentTypeLT", "detectedContentTypeLTE", "detectedContentTypeContains", "detectedContentTypeHasPrefix", "detectedContentTypeHasSuffix", "detectedContentTypeEqualFold", "detectedContentTypeContainsFold", "storeKey", "storeKeyNEQ", "storeKeyIn", "storeKeyNotIn", "storeKeyGT", "storeKeyGTE", "storeKeyLT", "storeKeyLTE", "storeKeyContains", "storeKeyHasPrefix", "storeKeyHasSuffix", "storeKeyIsNil", "storeKeyNotNil", "storeKeyEqualFold", "storeKeyContainsFold", "categoryType", "categoryTypeNEQ", "categoryTypeIn", "categoryTypeNotIn", "categoryTypeGT", "categoryTypeGTE", "categoryTypeLT", "categoryTypeLTE", "categoryTypeContains", "categoryTypeHasPrefix", "categoryTypeHasSuffix", "categoryTypeIsNil", "categoryTypeNotNil", "categoryTypeEqualFold", "categoryTypeContainsFold", "uri", "uriNEQ", "uriIn", "uriNotIn", "uriGT", "uriGTE", "uriLT", "uriLTE", "uriContains", "uriHasPrefix", "uriHasSuffix", "uriIsNil", "uriNotNil", "uriEqualFold", "uriContainsFold", "storageScheme", "storageSchemeNEQ", "storageSchemeIn", "storageSchemeNotIn", "storageSchemeGT", "storageSchemeGTE", "storageSchemeLT", "storageSchemeLTE", "storageSchemeContains", "storageSchemeHasPrefix", "storageSchemeHasSuffix", "storageSchemeIsNil", "storageSchemeNotNil", "storageSchemeEqualFold", "storageSchemeContainsFold", "storageVolume", "storageVolumeNEQ", "storageVolumeIn", "storageVolumeNotIn", "storageVolumeGT", "storageVolumeGTE", "storageVolumeLT", "storageVolumeLTE", "storageVolumeContains", "storageVolumeHasPrefix", "storageVolumeHasSuffix", "storageVolumeIsNil", "storageVolumeNotNil", "storageVolumeEqualFold", "storageVolumeContainsFold", "storagePath", "storagePathNEQ", "storagePathIn", "storagePathNotIn", "storagePathGT", "storagePathGTE", "storagePathLT", "storagePathLTE", "storagePathContains", "storagePathHasPrefix", "storagePathHasSuffix", "storagePathIsNil", "storagePathNotNil", "storagePathEqualFold", "storagePathContainsFold", "hasUser", "hasUserWith", "hasOrganization", "hasOrganizationWith", "hasGroup", "hasGroupWith", "hasContact", "hasContactWith", "hasEntity", "hasEntityWith", "hasUsersetting", "hasUsersettingWith", "hasOrganizationsetting", "hasOrganizationsettingWith", "hasTemplate", "hasTemplateWith", "hasDocumentdata", "hasDocumentdataWith", "hasEvents", "hasEventsWith", "hasProgram", "hasProgramWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -276607,21 +284343,21 @@ func (ec *executionContext) unmarshalInputFileHistoryWhereInput(ctx context.Cont switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOFileHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileHistoryWhereInput(ctx, v) + data, err := ec.unmarshalOFileWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOFileHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOFileHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -276696,195 +284432,6 @@ func (ec *executionContext) unmarshalInputFileHistoryWhereInput(ctx context.Cont return it, err } it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOFileHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOFileHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOFileHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOFileHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -278011,2753 +285558,1976 @@ func (ec *executionContext) unmarshalInputFileHistoryWhereInput(ctx context.Cont if err != nil { return it, err } - it.DetectedContentTypeHasPrefix = data - case "detectedContentTypeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DetectedContentTypeHasSuffix = data - case "detectedContentTypeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DetectedContentTypeEqualFold = data - case "detectedContentTypeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DetectedContentTypeContainsFold = data - case "storeKey": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKey")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKey = data - case "storeKeyNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyNEQ = data - case "storeKeyIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyIn = data - case "storeKeyNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyNotIn = data - case "storeKeyGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyGT = data - case "storeKeyGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyGTE = data - case "storeKeyLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyLT = data - case "storeKeyLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyLTE = data - case "storeKeyContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyContains = data - case "storeKeyHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyHasPrefix = data - case "storeKeyHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyHasSuffix = data - case "storeKeyIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyIsNil = data - case "storeKeyNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyNotNil = data - case "storeKeyEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyEqualFold = data - case "storeKeyContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyContainsFold = data - case "categoryType": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryType")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryType = data - case "categoryTypeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeNEQ = data - case "categoryTypeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeIn = data - case "categoryTypeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeNotIn = data - case "categoryTypeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeGT = data - case "categoryTypeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeGTE = data - case "categoryTypeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeLT = data - case "categoryTypeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeLTE = data - case "categoryTypeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeContains = data - case "categoryTypeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeHasPrefix = data - case "categoryTypeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeHasSuffix = data - case "categoryTypeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeIsNil = data - case "categoryTypeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeNotNil = data - case "categoryTypeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeEqualFold = data - case "categoryTypeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.CategoryTypeContainsFold = data - case "uri": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uri")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URI = data - case "uriNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URINEQ = data - case "uriIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.URIIn = data - case "uriNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.URINotIn = data - case "uriGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URIGT = data - case "uriGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URIGTE = data - case "uriLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URILT = data - case "uriLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URILTE = data - case "uriContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URIContains = data - case "uriHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URIHasPrefix = data - case "uriHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URIHasSuffix = data - case "uriIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.URIIsNil = data - case "uriNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.URINotNil = data - case "uriEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URIEqualFold = data - case "uriContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URIContainsFold = data - case "storageScheme": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageScheme")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageScheme = data - case "storageSchemeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeNEQ = data - case "storageSchemeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeIn = data - case "storageSchemeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeNotIn = data - case "storageSchemeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeGT = data - case "storageSchemeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeGTE = data - case "storageSchemeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeLT = data - case "storageSchemeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeLTE = data - case "storageSchemeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeContains = data - case "storageSchemeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeHasPrefix = data - case "storageSchemeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeHasSuffix = data - case "storageSchemeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeIsNil = data - case "storageSchemeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeNotNil = data - case "storageSchemeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeEqualFold = data - case "storageSchemeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeContainsFold = data - case "storageVolume": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolume")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolume = data - case "storageVolumeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeNEQ = data - case "storageVolumeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeIn = data - case "storageVolumeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeNotIn = data - case "storageVolumeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeGT = data - case "storageVolumeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeGTE = data - case "storageVolumeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeLT = data - case "storageVolumeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeLTE = data - case "storageVolumeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeContains = data - case "storageVolumeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeHasPrefix = data - case "storageVolumeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeHasSuffix = data - case "storageVolumeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeIsNil = data - case "storageVolumeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeNotNil = data - case "storageVolumeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeEqualFold = data - case "storageVolumeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageVolumeContainsFold = data - case "storagePath": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePath")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePath = data - case "storagePathNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathNEQ = data - case "storagePathIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.StoragePathIn = data - case "storagePathNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.StoragePathNotIn = data - case "storagePathGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathGT = data - case "storagePathGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathGTE = data - case "storagePathLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathLT = data - case "storagePathLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathLTE = data - case "storagePathContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathContains = data - case "storagePathHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathHasPrefix = data - case "storagePathHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathHasSuffix = data - case "storagePathIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StoragePathIsNil = data - case "storagePathNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StoragePathNotNil = data - case "storagePathEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathEqualFold = data - case "storagePathContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoragePathContainsFold = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputFileWhereInput(ctx context.Context, obj interface{}) (generated.FileWhereInput, error) { - var it generated.FileWhereInput - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "providedFileName", "providedFileNameNEQ", "providedFileNameIn", "providedFileNameNotIn", "providedFileNameGT", "providedFileNameGTE", "providedFileNameLT", "providedFileNameLTE", "providedFileNameContains", "providedFileNameHasPrefix", "providedFileNameHasSuffix", "providedFileNameEqualFold", "providedFileNameContainsFold", "providedFileExtension", "providedFileExtensionNEQ", "providedFileExtensionIn", "providedFileExtensionNotIn", "providedFileExtensionGT", "providedFileExtensionGTE", "providedFileExtensionLT", "providedFileExtensionLTE", "providedFileExtensionContains", "providedFileExtensionHasPrefix", "providedFileExtensionHasSuffix", "providedFileExtensionEqualFold", "providedFileExtensionContainsFold", "providedFileSize", "providedFileSizeNEQ", "providedFileSizeIn", "providedFileSizeNotIn", "providedFileSizeGT", "providedFileSizeGTE", "providedFileSizeLT", "providedFileSizeLTE", "providedFileSizeIsNil", "providedFileSizeNotNil", "persistedFileSize", "persistedFileSizeNEQ", "persistedFileSizeIn", "persistedFileSizeNotIn", "persistedFileSizeGT", "persistedFileSizeGTE", "persistedFileSizeLT", "persistedFileSizeLTE", "persistedFileSizeIsNil", "persistedFileSizeNotNil", "detectedMimeType", "detectedMimeTypeNEQ", "detectedMimeTypeIn", "detectedMimeTypeNotIn", "detectedMimeTypeGT", "detectedMimeTypeGTE", "detectedMimeTypeLT", "detectedMimeTypeLTE", "detectedMimeTypeContains", "detectedMimeTypeHasPrefix", "detectedMimeTypeHasSuffix", "detectedMimeTypeIsNil", "detectedMimeTypeNotNil", "detectedMimeTypeEqualFold", "detectedMimeTypeContainsFold", "md5Hash", "md5HashNEQ", "md5HashIn", "md5HashNotIn", "md5HashGT", "md5HashGTE", "md5HashLT", "md5HashLTE", "md5HashContains", "md5HashHasPrefix", "md5HashHasSuffix", "md5HashIsNil", "md5HashNotNil", "md5HashEqualFold", "md5HashContainsFold", "detectedContentType", "detectedContentTypeNEQ", "detectedContentTypeIn", "detectedContentTypeNotIn", "detectedContentTypeGT", "detectedContentTypeGTE", "detectedContentTypeLT", "detectedContentTypeLTE", "detectedContentTypeContains", "detectedContentTypeHasPrefix", "detectedContentTypeHasSuffix", "detectedContentTypeEqualFold", "detectedContentTypeContainsFold", "storeKey", "storeKeyNEQ", "storeKeyIn", "storeKeyNotIn", "storeKeyGT", "storeKeyGTE", "storeKeyLT", "storeKeyLTE", "storeKeyContains", "storeKeyHasPrefix", "storeKeyHasSuffix", "storeKeyIsNil", "storeKeyNotNil", "storeKeyEqualFold", "storeKeyContainsFold", "categoryType", "categoryTypeNEQ", "categoryTypeIn", "categoryTypeNotIn", "categoryTypeGT", "categoryTypeGTE", "categoryTypeLT", "categoryTypeLTE", "categoryTypeContains", "categoryTypeHasPrefix", "categoryTypeHasSuffix", "categoryTypeIsNil", "categoryTypeNotNil", "categoryTypeEqualFold", "categoryTypeContainsFold", "uri", "uriNEQ", "uriIn", "uriNotIn", "uriGT", "uriGTE", "uriLT", "uriLTE", "uriContains", "uriHasPrefix", "uriHasSuffix", "uriIsNil", "uriNotNil", "uriEqualFold", "uriContainsFold", "storageScheme", "storageSchemeNEQ", "storageSchemeIn", "storageSchemeNotIn", "storageSchemeGT", "storageSchemeGTE", "storageSchemeLT", "storageSchemeLTE", "storageSchemeContains", "storageSchemeHasPrefix", "storageSchemeHasSuffix", "storageSchemeIsNil", "storageSchemeNotNil", "storageSchemeEqualFold", "storageSchemeContainsFold", "storageVolume", "storageVolumeNEQ", "storageVolumeIn", "storageVolumeNotIn", "storageVolumeGT", "storageVolumeGTE", "storageVolumeLT", "storageVolumeLTE", "storageVolumeContains", "storageVolumeHasPrefix", "storageVolumeHasSuffix", "storageVolumeIsNil", "storageVolumeNotNil", "storageVolumeEqualFold", "storageVolumeContainsFold", "storagePath", "storagePathNEQ", "storagePathIn", "storagePathNotIn", "storagePathGT", "storagePathGTE", "storagePathLT", "storagePathLTE", "storagePathContains", "storagePathHasPrefix", "storagePathHasSuffix", "storagePathIsNil", "storagePathNotNil", "storagePathEqualFold", "storagePathContainsFold", "hasUser", "hasUserWith", "hasOrganization", "hasOrganizationWith", "hasGroup", "hasGroupWith", "hasContact", "hasContactWith", "hasEntity", "hasEntityWith", "hasUsersetting", "hasUsersettingWith", "hasOrganizationsetting", "hasOrganizationsettingWith", "hasTemplate", "hasTemplateWith", "hasDocumentdata", "hasDocumentdataWith", "hasEvents", "hasEventsWith", "hasProgram", "hasProgramWith"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "not": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOFileWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInput(ctx, v) - if err != nil { - return it, err - } - it.Not = data - case "and": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.And = data - case "or": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.Or = data - case "id": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ID = data - case "idNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.IDNEQ = data - case "idIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.IDIn = data - case "idNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.IDNotIn = data - case "idGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.IDGT = data - case "idGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.IDGTE = data - case "idLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.IDLT = data - case "idLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.IDLTE = data - case "idEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.IDEqualFold = data - case "idContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.IDContainsFold = data - case "createdAt": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.CreatedAt = data - case "createdAtNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.CreatedAtNEQ = data - case "createdAtIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.CreatedAtIn = data - case "createdAtNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.DetectedContentTypeHasPrefix = data + case "detectedContentTypeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedAtNotIn = data - case "createdAtGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.DetectedContentTypeHasSuffix = data + case "detectedContentTypeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedAtGT = data - case "createdAtGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.DetectedContentTypeEqualFold = data + case "detectedContentTypeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedAtGTE = data - case "createdAtLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.DetectedContentTypeContainsFold = data + case "storeKey": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKey")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedAtLT = data - case "createdAtLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StoreKey = data + case "storeKeyNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedAtLTE = data - case "createdAtIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.StoreKeyNEQ = data + case "storeKeyIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CreatedAtIsNil = data - case "createdAtNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.StoreKeyIn = data + case "storeKeyNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CreatedAtNotNil = data - case "updatedAt": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StoreKeyNotIn = data + case "storeKeyGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedAt = data - case "updatedAtNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StoreKeyGT = data + case "storeKeyGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedAtNEQ = data - case "updatedAtIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.StoreKeyGTE = data + case "storeKeyLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedAtIn = data - case "updatedAtNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.StoreKeyLT = data + case "storeKeyLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedAtNotIn = data - case "updatedAtGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StoreKeyLTE = data + case "storeKeyContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedAtGT = data - case "updatedAtGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StoreKeyContains = data + case "storeKeyHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedAtGTE = data - case "updatedAtLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StoreKeyHasPrefix = data + case "storeKeyHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedAtLT = data - case "updatedAtLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StoreKeyHasSuffix = data + case "storeKeyIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.UpdatedAtLTE = data - case "updatedAtIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIsNil")) + it.StoreKeyIsNil = data + case "storeKeyNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.UpdatedAtIsNil = data - case "updatedAtNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.StoreKeyNotNil = data + case "storeKeyEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedAtNotNil = data - case "createdBy": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy")) + it.StoreKeyEqualFold = data + case "storeKeyContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedBy = data - case "createdByNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNEQ")) + it.StoreKeyContainsFold = data + case "categoryType": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryType")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByNEQ = data - case "createdByIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIn")) + it.CategoryType = data + case "categoryTypeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.CategoryTypeNEQ = data + case "categoryTypeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CreatedByIn = data - case "createdByNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotIn")) + it.CategoryTypeIn = data + case "categoryTypeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CreatedByNotIn = data - case "createdByGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGT")) + it.CategoryTypeNotIn = data + case "categoryTypeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByGT = data - case "createdByGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGTE")) + it.CategoryTypeGT = data + case "categoryTypeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByGTE = data - case "createdByLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLT")) + it.CategoryTypeGTE = data + case "categoryTypeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByLT = data - case "createdByLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLTE")) + it.CategoryTypeLT = data + case "categoryTypeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByLTE = data - case "createdByContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContains")) + it.CategoryTypeLTE = data + case "categoryTypeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByContains = data - case "createdByHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasPrefix")) + it.CategoryTypeContains = data + case "categoryTypeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByHasPrefix = data - case "createdByHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasSuffix")) + it.CategoryTypeHasPrefix = data + case "categoryTypeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByHasSuffix = data - case "createdByIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIsNil")) + it.CategoryTypeHasSuffix = data + case "categoryTypeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CreatedByIsNil = data - case "createdByNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotNil")) + it.CategoryTypeIsNil = data + case "categoryTypeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CreatedByNotNil = data - case "createdByEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByEqualFold")) + it.CategoryTypeNotNil = data + case "categoryTypeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByEqualFold = data - case "createdByContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContainsFold")) + it.CategoryTypeEqualFold = data + case "categoryTypeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CreatedByContainsFold = data - case "updatedBy": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy")) + it.CategoryTypeContainsFold = data + case "uri": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uri")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedBy = data - case "updatedByNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNEQ")) + it.URI = data + case "uriNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByNEQ = data - case "updatedByIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIn")) + it.URINEQ = data + case "uriIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.UpdatedByIn = data - case "updatedByNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotIn")) + it.URIIn = data + case "uriNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.UpdatedByNotIn = data - case "updatedByGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGT")) + it.URINotIn = data + case "uriGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByGT = data - case "updatedByGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGTE")) + it.URIGT = data + case "uriGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByGTE = data - case "updatedByLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLT")) + it.URIGTE = data + case "uriLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByLT = data - case "updatedByLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLTE")) + it.URILT = data + case "uriLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByLTE = data - case "updatedByContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContains")) + it.URILTE = data + case "uriContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByContains = data - case "updatedByHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasPrefix")) + it.URIContains = data + case "uriHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByHasPrefix = data - case "updatedByHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasSuffix")) + it.URIHasPrefix = data + case "uriHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByHasSuffix = data - case "updatedByIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIsNil")) + it.URIHasSuffix = data + case "uriIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.UpdatedByIsNil = data - case "updatedByNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotNil")) + it.URIIsNil = data + case "uriNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.UpdatedByNotNil = data - case "updatedByEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByEqualFold")) + it.URINotNil = data + case "uriEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByEqualFold = data - case "updatedByContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContainsFold")) + it.URIEqualFold = data + case "uriContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UpdatedByContainsFold = data - case "deletedAt": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAt")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.URIContainsFold = data + case "storageScheme": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageScheme")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAt = data - case "deletedAtNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StorageScheme = data + case "storageSchemeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtNEQ = data - case "deletedAtIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.StorageSchemeNEQ = data + case "storageSchemeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DeletedAtIn = data - case "deletedAtNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.StorageSchemeIn = data + case "storageSchemeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DeletedAtNotIn = data - case "deletedAtGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StorageSchemeNotIn = data + case "storageSchemeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtGT = data - case "deletedAtGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StorageSchemeGT = data + case "storageSchemeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtGTE = data - case "deletedAtLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StorageSchemeGTE = data + case "storageSchemeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtLT = data - case "deletedAtLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.StorageSchemeLT = data + case "storageSchemeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedAtLTE = data - case "deletedAtIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIsNil")) + it.StorageSchemeLTE = data + case "storageSchemeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StorageSchemeContains = data + case "storageSchemeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StorageSchemeHasPrefix = data + case "storageSchemeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StorageSchemeHasSuffix = data + case "storageSchemeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DeletedAtIsNil = data - case "deletedAtNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotNil")) + it.StorageSchemeIsNil = data + case "storageSchemeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DeletedAtNotNil = data - case "deletedBy": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedBy")) + it.StorageSchemeNotNil = data + case "storageSchemeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedBy = data - case "deletedByNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNEQ")) + it.StorageSchemeEqualFold = data + case "storageSchemeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByNEQ = data - case "deletedByIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIn")) + it.StorageSchemeContainsFold = data + case "storageVolume": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolume")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StorageVolume = data + case "storageVolumeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StorageVolumeNEQ = data + case "storageVolumeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DeletedByIn = data - case "deletedByNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotIn")) + it.StorageVolumeIn = data + case "storageVolumeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DeletedByNotIn = data - case "deletedByGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGT")) + it.StorageVolumeNotIn = data + case "storageVolumeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByGT = data - case "deletedByGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGTE")) + it.StorageVolumeGT = data + case "storageVolumeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByGTE = data - case "deletedByLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLT")) + it.StorageVolumeGTE = data + case "storageVolumeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByLT = data - case "deletedByLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLTE")) + it.StorageVolumeLT = data + case "storageVolumeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByLTE = data - case "deletedByContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContains")) + it.StorageVolumeLTE = data + case "storageVolumeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByContains = data - case "deletedByHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasPrefix")) + it.StorageVolumeContains = data + case "storageVolumeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByHasPrefix = data - case "deletedByHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasSuffix")) + it.StorageVolumeHasPrefix = data + case "storageVolumeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByHasSuffix = data - case "deletedByIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIsNil")) + it.StorageVolumeHasSuffix = data + case "storageVolumeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DeletedByIsNil = data - case "deletedByNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotNil")) + it.StorageVolumeIsNil = data + case "storageVolumeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DeletedByNotNil = data - case "deletedByEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByEqualFold")) + it.StorageVolumeNotNil = data + case "storageVolumeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByEqualFold = data - case "deletedByContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContainsFold")) + it.StorageVolumeEqualFold = data + case "storageVolumeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DeletedByContainsFold = data - case "providedFileName": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileName")) + it.StorageVolumeContainsFold = data + case "storagePath": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePath")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileName = data - case "providedFileNameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameNEQ")) + it.StoragePath = data + case "storagePathNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameNEQ = data - case "providedFileNameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameIn")) + it.StoragePathNEQ = data + case "storagePathIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameIn = data - case "providedFileNameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameNotIn")) + it.StoragePathIn = data + case "storagePathNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameNotIn = data - case "providedFileNameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameGT")) + it.StoragePathNotIn = data + case "storagePathGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameGT = data - case "providedFileNameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameGTE")) + it.StoragePathGT = data + case "storagePathGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameGTE = data - case "providedFileNameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameLT")) + it.StoragePathGTE = data + case "storagePathLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameLT = data - case "providedFileNameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameLTE")) + it.StoragePathLT = data + case "storagePathLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameLTE = data - case "providedFileNameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameContains")) + it.StoragePathLTE = data + case "storagePathContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameContains = data - case "providedFileNameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameHasPrefix")) + it.StoragePathContains = data + case "storagePathHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameHasPrefix = data - case "providedFileNameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameHasSuffix")) + it.StoragePathHasPrefix = data + case "storagePathHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameHasSuffix = data - case "providedFileNameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.StoragePathHasSuffix = data + case "storagePathIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameEqualFold = data - case "providedFileNameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileNameContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.StoragePathIsNil = data + case "storagePathNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ProvidedFileNameContainsFold = data - case "providedFileExtension": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtension")) + it.StoragePathNotNil = data + case "storagePathEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtension = data - case "providedFileExtensionNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionNEQ")) + it.StoragePathEqualFold = data + case "storagePathContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionNEQ = data - case "providedFileExtensionIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ProvidedFileExtensionIn = data - case "providedFileExtensionNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.StoragePathContainsFold = data + case "hasUser": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUser")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionNotIn = data - case "providedFileExtensionGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasUser = data + case "hasUserWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUserWith")) + data, err := ec.unmarshalOUserWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionGT = data - case "providedFileExtensionGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasUserWith = data + case "hasOrganization": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganization")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionGTE = data - case "providedFileExtensionLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasOrganization = data + case "hasOrganizationWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionLT = data - case "providedFileExtensionLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasOrganizationWith = data + case "hasGroup": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroup")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionLTE = data - case "providedFileExtensionContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasGroup = data + case "hasGroupWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupWith")) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionContains = data - case "providedFileExtensionHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasGroupWith = data + case "hasContact": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasContact")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionHasPrefix = data - case "providedFileExtensionHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasContact = data + case "hasContactWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasContactWith")) + data, err := ec.unmarshalOContactWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐContactWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionHasSuffix = data - case "providedFileExtensionEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasContactWith = data + case "hasEntity": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntity")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionEqualFold = data - case "providedFileExtensionContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileExtensionContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasEntity = data + case "hasEntityWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntityWith")) + data, err := ec.unmarshalOEntityWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileExtensionContainsFold = data - case "providedFileSize": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSize")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.HasEntityWith = data + case "hasUsersetting": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUsersetting")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileSize = data - case "providedFileSizeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeNEQ")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.HasUsersetting = data + case "hasUsersettingWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUsersettingWith")) + data, err := ec.unmarshalOUserSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserSettingWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileSizeNEQ = data - case "providedFileSizeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeIn")) - data, err := ec.unmarshalOInt2ᚕint64ᚄ(ctx, v) + it.HasUsersettingWith = data + case "hasOrganizationsetting": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationsetting")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileSizeIn = data - case "providedFileSizeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeNotIn")) - data, err := ec.unmarshalOInt2ᚕint64ᚄ(ctx, v) + it.HasOrganizationsetting = data + case "hasOrganizationsettingWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationsettingWith")) + data, err := ec.unmarshalOOrganizationSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationSettingWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileSizeNotIn = data - case "providedFileSizeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeGT")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.HasOrganizationsettingWith = data + case "hasTemplate": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTemplate")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileSizeGT = data - case "providedFileSizeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeGTE")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.HasTemplate = data + case "hasTemplateWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTemplateWith")) + data, err := ec.unmarshalOTemplateWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileSizeGTE = data - case "providedFileSizeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeLT")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.HasTemplateWith = data + case "hasDocumentdata": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasDocumentdata")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileSizeLT = data - case "providedFileSizeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeLTE")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.HasDocumentdata = data + case "hasDocumentdataWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasDocumentdataWith")) + data, err := ec.unmarshalODocumentDataWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐDocumentDataWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileSizeLTE = data - case "providedFileSizeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.HasDocumentdataWith = data + case "hasEvents": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ProvidedFileSizeIsNil = data - case "providedFileSizeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("providedFileSizeNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.HasEvents = data + case "hasEventsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) + data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.ProvidedFileSizeNotNil = data - case "persistedFileSize": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSize")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.HasEventsWith = data + case "hasProgram": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgram")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.PersistedFileSize = data - case "persistedFileSizeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeNEQ")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.HasProgram = data + case "hasProgramWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramWith")) + data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.PersistedFileSizeNEQ = data - case "persistedFileSizeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeIn")) - data, err := ec.unmarshalOInt2ᚕint64ᚄ(ctx, v) + it.HasProgramWith = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputGroupHistoryOrder(ctx context.Context, obj interface{}) (generated.GroupHistoryOrder, error) { + var it generated.GroupHistoryOrder + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + if _, present := asMap["direction"]; !present { + asMap["direction"] = "ASC" + } + + fieldsInOrder := [...]string{"direction", "field"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "direction": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction")) + data, err := ec.unmarshalNOrderDirection2entgoᚗioᚋcontribᚋentgqlᚐOrderDirection(ctx, v) if err != nil { return it, err } - it.PersistedFileSizeIn = data - case "persistedFileSizeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeNotIn")) - data, err := ec.unmarshalOInt2ᚕint64ᚄ(ctx, v) + it.Direction = data + case "field": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) + data, err := ec.unmarshalNGroupHistoryOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupHistoryOrderField(ctx, v) if err != nil { return it, err } - it.PersistedFileSizeNotIn = data - case "persistedFileSizeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeGT")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.Field = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputGroupHistoryWhereInput(ctx context.Context, obj interface{}) (generated.GroupHistoryWhereInput, error) { + var it generated.GroupHistoryWhereInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameEqualFold", "displayNameContainsFold"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) + data, err := ec.unmarshalOGroupHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupHistoryWhereInput(ctx, v) if err != nil { return it, err } - it.PersistedFileSizeGT = data - case "persistedFileSizeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeGTE")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.Not = data + case "and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) + data, err := ec.unmarshalOGroupHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.PersistedFileSizeGTE = data - case "persistedFileSizeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeLT")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.And = data + case "or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) + data, err := ec.unmarshalOGroupHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.PersistedFileSizeLT = data - case "persistedFileSizeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeLTE")) - data, err := ec.unmarshalOInt2ᚖint64(ctx, v) + it.Or = data + case "id": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.PersistedFileSizeLTE = data - case "persistedFileSizeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.ID = data + case "idNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.PersistedFileSizeIsNil = data - case "persistedFileSizeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("persistedFileSizeNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.IDNEQ = data + case "idIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.PersistedFileSizeNotNil = data - case "detectedMimeType": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeType")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDIn = data + case "idNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DetectedMimeType = data - case "detectedMimeTypeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDNotIn = data + case "idGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeNEQ = data - case "detectedMimeTypeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.IDGT = data + case "idGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeIn = data - case "detectedMimeTypeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.IDGTE = data + case "idLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeNotIn = data - case "detectedMimeTypeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDLT = data + case "idLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeGT = data - case "detectedMimeTypeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDLTE = data + case "idEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeGTE = data - case "detectedMimeTypeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDEqualFold = data + case "idContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeLT = data - case "detectedMimeTypeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeLTE = data - case "detectedMimeTypeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeContains = data - case "detectedMimeTypeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeHasPrefix = data - case "detectedMimeTypeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeHasSuffix = data - case "detectedMimeTypeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeIsNil = data - case "detectedMimeTypeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeNotNil = data - case "detectedMimeTypeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeEqualFold = data - case "detectedMimeTypeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedMimeTypeContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedMimeTypeContainsFold = data - case "md5Hash": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5Hash")) + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Md5Hash = data - case "md5HashNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashNEQ")) + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Md5HashNEQ = data - case "md5HashIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashIn")) + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.Md5HashIn = data - case "md5HashNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashNotIn")) + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.Md5HashNotIn = data - case "md5HashGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashGT")) + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Md5HashGT = data - case "md5HashGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashGTE")) + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Md5HashGTE = data - case "md5HashLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashLT")) + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Md5HashLT = data - case "md5HashLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashLTE")) + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Md5HashLTE = data - case "md5HashContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashContains")) + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Md5HashContains = data - case "md5HashHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashHasPrefix")) + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Md5HashHasPrefix = data - case "md5HashHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashHasSuffix")) + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Md5HashHasSuffix = data - case "md5HashIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashIsNil")) + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.Md5HashIsNil = data - case "md5HashNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashNotNil")) + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.Md5HashNotNil = data - case "md5HashEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Md5HashEqualFold = data - case "md5HashContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("md5HashContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Md5HashContainsFold = data - case "detectedContentType": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentType")) + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DetectedContentType = data - case "detectedContentTypeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeNEQ")) + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeNEQ = data - case "detectedContentTypeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOGroupHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeIn = data - case "detectedContentTypeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOGroupHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeNotIn = data - case "detectedContentTypeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOGroupHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeGT = data - case "detectedContentTypeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOGroupHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeGTE = data - case "detectedContentTypeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.OperationNotIn = data + case "createdAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeLT = data - case "detectedContentTypeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAt = data + case "createdAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeLTE = data - case "detectedContentTypeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtNEQ = data + case "createdAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeContains = data - case "detectedContentTypeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtIn = data + case "createdAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeHasPrefix = data - case "detectedContentTypeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtNotIn = data + case "createdAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeHasSuffix = data - case "detectedContentTypeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtGT = data + case "createdAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeEqualFold = data - case "detectedContentTypeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("detectedContentTypeContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtGTE = data + case "createdAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.DetectedContentTypeContainsFold = data - case "storeKey": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKey")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtLT = data + case "createdAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StoreKey = data - case "storeKeyNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtLTE = data + case "createdAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StoreKeyNEQ = data - case "storeKeyIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.CreatedAtIsNil = data + case "createdAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StoreKeyIn = data - case "storeKeyNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.CreatedAtNotNil = data + case "updatedAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StoreKeyNotIn = data - case "storeKeyGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAt = data + case "updatedAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StoreKeyGT = data - case "storeKeyGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtNEQ = data + case "updatedAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.StoreKeyGTE = data - case "storeKeyLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtIn = data + case "updatedAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.StoreKeyLT = data - case "storeKeyLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtNotIn = data + case "updatedAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StoreKeyLTE = data - case "storeKeyContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtGT = data + case "updatedAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StoreKeyContains = data - case "storeKeyHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtGTE = data + case "updatedAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StoreKeyHasPrefix = data - case "storeKeyHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtLT = data + case "updatedAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StoreKeyHasSuffix = data - case "storeKeyIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyIsNil")) + it.UpdatedAtLTE = data + case "updatedAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StoreKeyIsNil = data - case "storeKeyNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyNotNil")) + it.UpdatedAtIsNil = data + case "updatedAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StoreKeyNotNil = data - case "storeKeyEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyEqualFold = data - case "storeKeyContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storeKeyContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StoreKeyContainsFold = data - case "categoryType": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryType")) + it.UpdatedAtNotNil = data + case "createdBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryType = data - case "categoryTypeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNEQ")) + it.CreatedBy = data + case "createdByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeNEQ = data - case "categoryTypeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeIn")) + it.CreatedByNEQ = data + case "createdByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CategoryTypeIn = data - case "categoryTypeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNotIn")) + it.CreatedByIn = data + case "createdByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.CategoryTypeNotIn = data - case "categoryTypeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeGT")) + it.CreatedByNotIn = data + case "createdByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeGT = data - case "categoryTypeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeGTE")) + it.CreatedByGT = data + case "createdByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeGTE = data - case "categoryTypeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeLT")) + it.CreatedByGTE = data + case "createdByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeLT = data - case "categoryTypeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeLTE")) + it.CreatedByLT = data + case "createdByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeLTE = data - case "categoryTypeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeContains")) + it.CreatedByLTE = data + case "createdByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeContains = data - case "categoryTypeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeHasPrefix")) + it.CreatedByContains = data + case "createdByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeHasPrefix = data - case "categoryTypeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeHasSuffix")) + it.CreatedByHasPrefix = data + case "createdByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeHasSuffix = data - case "categoryTypeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeIsNil")) + it.CreatedByHasSuffix = data + case "createdByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CategoryTypeIsNil = data - case "categoryTypeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeNotNil")) + it.CreatedByIsNil = data + case "createdByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.CategoryTypeNotNil = data - case "categoryTypeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeEqualFold")) + it.CreatedByNotNil = data + case "createdByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeEqualFold = data - case "categoryTypeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("categoryTypeContainsFold")) + it.CreatedByEqualFold = data + case "createdByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.CategoryTypeContainsFold = data - case "uri": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uri")) + it.CreatedByContainsFold = data + case "updatedBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.URI = data - case "uriNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNEQ")) + it.UpdatedBy = data + case "updatedByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.URINEQ = data - case "uriIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriIn")) + it.UpdatedByNEQ = data + case "updatedByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.URIIn = data - case "uriNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNotIn")) + it.UpdatedByIn = data + case "updatedByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.URINotIn = data - case "uriGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriGT")) + it.UpdatedByNotIn = data + case "updatedByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.URIGT = data - case "uriGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriGTE")) + it.UpdatedByGT = data + case "updatedByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.URIGTE = data - case "uriLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriLT")) + it.UpdatedByGTE = data + case "updatedByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.URILT = data - case "uriLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriLTE")) + it.UpdatedByLT = data + case "updatedByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.URILTE = data - case "uriContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriContains")) + it.UpdatedByLTE = data + case "updatedByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.URIContains = data - case "uriHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriHasPrefix")) + it.UpdatedByContains = data + case "updatedByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.URIHasPrefix = data - case "uriHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriHasSuffix")) + it.UpdatedByHasPrefix = data + case "updatedByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.URIHasSuffix = data - case "uriIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriIsNil")) + it.UpdatedByHasSuffix = data + case "updatedByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.URIIsNil = data - case "uriNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriNotNil")) + it.UpdatedByIsNil = data + case "updatedByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.URINotNil = data - case "uriEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URIEqualFold = data - case "uriContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("uriContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.URIContainsFold = data - case "storageScheme": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageScheme")) + it.UpdatedByNotNil = data + case "updatedByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageScheme = data - case "storageSchemeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNEQ")) + it.UpdatedByEqualFold = data + case "updatedByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageSchemeNEQ = data - case "storageSchemeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeIn = data - case "storageSchemeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.UpdatedByContainsFold = data + case "deletedAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StorageSchemeNotIn = data - case "storageSchemeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAt = data + case "deletedAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StorageSchemeGT = data - case "storageSchemeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtNEQ = data + case "deletedAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.StorageSchemeGTE = data - case "storageSchemeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtIn = data + case "deletedAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.StorageSchemeLT = data - case "storageSchemeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtNotIn = data + case "deletedAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StorageSchemeLTE = data - case "storageSchemeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtGT = data + case "deletedAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StorageSchemeContains = data - case "storageSchemeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtGTE = data + case "deletedAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StorageSchemeHasPrefix = data - case "storageSchemeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtLT = data + case "deletedAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.StorageSchemeHasSuffix = data - case "storageSchemeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeIsNil")) + it.DeletedAtLTE = data + case "deletedAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StorageSchemeIsNil = data - case "storageSchemeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeNotNil")) + it.DeletedAtIsNil = data + case "deletedAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StorageSchemeNotNil = data - case "storageSchemeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeEqualFold = data - case "storageSchemeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageSchemeContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StorageSchemeContainsFold = data - case "storageVolume": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolume")) + it.DeletedAtNotNil = data + case "deletedBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedBy")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolume = data - case "storageVolumeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNEQ")) + it.DeletedBy = data + case "deletedByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeNEQ = data - case "storageVolumeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeIn")) + it.DeletedByNEQ = data + case "deletedByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.StorageVolumeIn = data - case "storageVolumeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNotIn")) + it.DeletedByIn = data + case "deletedByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.StorageVolumeNotIn = data - case "storageVolumeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeGT")) + it.DeletedByNotIn = data + case "deletedByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeGT = data - case "storageVolumeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeGTE")) + it.DeletedByGT = data + case "deletedByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeGTE = data - case "storageVolumeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeLT")) + it.DeletedByGTE = data + case "deletedByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeLT = data - case "storageVolumeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeLTE")) + it.DeletedByLT = data + case "deletedByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeLTE = data - case "storageVolumeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeContains")) + it.DeletedByLTE = data + case "deletedByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeContains = data - case "storageVolumeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeHasPrefix")) + it.DeletedByContains = data + case "deletedByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeHasPrefix = data - case "storageVolumeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeHasSuffix")) + it.DeletedByHasPrefix = data + case "deletedByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeHasSuffix = data - case "storageVolumeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeIsNil")) + it.DeletedByHasSuffix = data + case "deletedByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StorageVolumeIsNil = data - case "storageVolumeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeNotNil")) + it.DeletedByIsNil = data + case "deletedByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StorageVolumeNotNil = data - case "storageVolumeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeEqualFold")) + it.DeletedByNotNil = data + case "deletedByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeEqualFold = data - case "storageVolumeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storageVolumeContainsFold")) + it.DeletedByEqualFold = data + case "deletedByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StorageVolumeContainsFold = data - case "storagePath": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePath")) + it.DeletedByContainsFold = data + case "ownerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePath = data - case "storagePathNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNEQ")) + it.OwnerID = data + case "ownerIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathNEQ = data - case "storagePathIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathIn")) + it.OwnerIDNEQ = data + case "ownerIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.StoragePathIn = data - case "storagePathNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNotIn")) + it.OwnerIDIn = data + case "ownerIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.StoragePathNotIn = data - case "storagePathGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathGT")) + it.OwnerIDNotIn = data + case "ownerIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathGT = data - case "storagePathGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathGTE")) + it.OwnerIDGT = data + case "ownerIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathGTE = data - case "storagePathLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathLT")) + it.OwnerIDGTE = data + case "ownerIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathLT = data - case "storagePathLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathLTE")) + it.OwnerIDLT = data + case "ownerIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathLTE = data - case "storagePathContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathContains")) + it.OwnerIDLTE = data + case "ownerIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathContains = data - case "storagePathHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathHasPrefix")) + it.OwnerIDContains = data + case "ownerIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathHasPrefix = data - case "storagePathHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathHasSuffix")) + it.OwnerIDHasPrefix = data + case "ownerIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathHasSuffix = data - case "storagePathIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathIsNil")) + it.OwnerIDHasSuffix = data + case "ownerIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StoragePathIsNil = data - case "storagePathNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathNotNil")) + it.OwnerIDIsNil = data + case "ownerIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.StoragePathNotNil = data - case "storagePathEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathEqualFold")) + it.OwnerIDNotNil = data + case "ownerIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathEqualFold = data - case "storagePathContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("storagePathContainsFold")) + it.OwnerIDEqualFold = data + case "ownerIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StoragePathContainsFold = data - case "hasUser": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUser")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.OwnerIDContainsFold = data + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasUser = data - case "hasUserWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUserWith")) - data, err := ec.unmarshalOUserWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserWhereInputᚄ(ctx, v) + it.Name = data + case "nameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasUserWith = data - case "hasOrganization": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganization")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameNEQ = data + case "nameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasOrganization = data - case "hasOrganizationWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + it.NameIn = data + case "nameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasOrganizationWith = data - case "hasGroup": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroup")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameNotIn = data + case "nameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasGroup = data - case "hasGroupWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupWith")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + it.NameGT = data + case "nameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasGroupWith = data - case "hasContact": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasContact")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameGTE = data + case "nameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasContact = data - case "hasContactWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasContactWith")) - data, err := ec.unmarshalOContactWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐContactWhereInputᚄ(ctx, v) + it.NameLT = data + case "nameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasContactWith = data - case "hasEntity": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntity")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameLTE = data + case "nameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEntity = data - case "hasEntityWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntityWith")) - data, err := ec.unmarshalOEntityWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityWhereInputᚄ(ctx, v) + it.NameContains = data + case "nameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEntityWith = data - case "hasUsersetting": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUsersetting")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameHasPrefix = data + case "nameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasUsersetting = data - case "hasUsersettingWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUsersettingWith")) - data, err := ec.unmarshalOUserSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserSettingWhereInputᚄ(ctx, v) + it.NameHasSuffix = data + case "nameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasUsersettingWith = data - case "hasOrganizationsetting": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationsetting")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameEqualFold = data + case "nameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOrganizationsetting = data - case "hasOrganizationsettingWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationsettingWith")) - data, err := ec.unmarshalOOrganizationSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationSettingWhereInputᚄ(ctx, v) + it.NameContainsFold = data + case "displayName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayName")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOrganizationsettingWith = data - case "hasTemplate": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTemplate")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayName = data + case "displayNameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasTemplate = data - case "hasTemplateWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTemplateWith")) - data, err := ec.unmarshalOTemplateWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTemplateWhereInputᚄ(ctx, v) + it.DisplayNameNEQ = data + case "displayNameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasTemplateWith = data - case "hasDocumentdata": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasDocumentdata")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameIn = data + case "displayNameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasDocumentdata = data - case "hasDocumentdataWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasDocumentdataWith")) - data, err := ec.unmarshalODocumentDataWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐDocumentDataWhereInputᚄ(ctx, v) + it.DisplayNameNotIn = data + case "displayNameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasDocumentdataWith = data - case "hasEvents": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameGT = data + case "displayNameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEvents = data - case "hasEventsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) - data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + it.DisplayNameGTE = data + case "displayNameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEventsWith = data - case "hasProgram": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgram")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DisplayNameLT = data + case "displayNameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasProgram = data - case "hasProgramWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramWith")) - data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) + it.DisplayNameLTE = data + case "displayNameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasProgramWith = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputGroupHistoryOrder(ctx context.Context, obj interface{}) (generated.GroupHistoryOrder, error) { - var it generated.GroupHistoryOrder - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - if _, present := asMap["direction"]; !present { - asMap["direction"] = "ASC" - } - - fieldsInOrder := [...]string{"direction", "field"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "direction": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction")) - data, err := ec.unmarshalNOrderDirection2entgoᚗioᚋcontribᚋentgqlᚐOrderDirection(ctx, v) + it.DisplayNameContains = data + case "displayNameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Direction = data - case "field": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) - data, err := ec.unmarshalNGroupHistoryOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupHistoryOrderField(ctx, v) + it.DisplayNameHasPrefix = data + case "displayNameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Field = data + it.DisplayNameHasSuffix = data + case "displayNameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameEqualFold = data + case "displayNameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameContainsFold = data } } return it, nil } -func (ec *executionContext) unmarshalInputGroupHistoryWhereInput(ctx context.Context, obj interface{}) (generated.GroupHistoryWhereInput, error) { - var it generated.GroupHistoryWhereInput +func (ec *executionContext) unmarshalInputGroupMembershipHistoryWhereInput(ctx context.Context, obj interface{}) (generated.GroupMembershipHistoryWhereInput, error) { + var it generated.GroupMembershipHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameEqualFold", "displayNameContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "role", "roleNEQ", "roleIn", "roleNotIn", "groupID", "groupIDNEQ", "groupIDIn", "groupIDNotIn", "groupIDGT", "groupIDGTE", "groupIDLT", "groupIDLTE", "groupIDContains", "groupIDHasPrefix", "groupIDHasSuffix", "groupIDEqualFold", "groupIDContainsFold", "userID", "userIDNEQ", "userIDIn", "userIDNotIn", "userIDGT", "userIDGTE", "userIDLT", "userIDLTE", "userIDContains", "userIDHasPrefix", "userIDHasSuffix", "userIDEqualFold", "userIDContainsFold"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -280766,21 +287536,21 @@ func (ec *executionContext) unmarshalInputGroupHistoryWhereInput(ctx context.Con switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOGroupHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupHistoryWhereInput(ctx, v) + data, err := ec.unmarshalOGroupMembershipHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOGroupHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOGroupMembershipHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOGroupHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOGroupMembershipHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -281018,28 +287788,28 @@ func (ec *executionContext) unmarshalInputGroupHistoryWhereInput(ctx context.Con it.RefContainsFold = data case "operation": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOGroupHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + data, err := ec.unmarshalOGroupMembershipHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } it.Operation = data case "operationNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOGroupHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + data, err := ec.unmarshalOGroupMembershipHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } it.OperationNEQ = data case "operationIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOGroupHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + data, err := ec.unmarshalOGroupMembershipHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } it.OperationIn = data case "operationNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOGroupHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + data, err := ec.unmarshalOGroupMembershipHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } @@ -281569,307 +288339,230 @@ func (ec *executionContext) unmarshalInputGroupHistoryWhereInput(ctx context.Con return it, err } it.DeletedByContainsFold = data - case "ownerID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerID = data - case "ownerIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDNEQ = data - case "ownerIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDIn = data - case "ownerIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDNotIn = data - case "ownerIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDGT = data - case "ownerIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDGTE = data - case "ownerIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDLT = data - case "ownerIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDLTE = data - case "ownerIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDContains = data - case "ownerIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDHasPrefix = data - case "ownerIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDHasSuffix = data - case "ownerIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + case "role": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) + data, err := ec.unmarshalOGroupMembershipHistoryRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } - it.OwnerIDIsNil = data - case "ownerIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.Role = data + case "roleNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNEQ")) + data, err := ec.unmarshalOGroupMembershipHistoryRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } - it.OwnerIDNotNil = data - case "ownerIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.RoleNEQ = data + case "roleIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleIn")) + data, err := ec.unmarshalOGroupMembershipHistoryRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } - it.OwnerIDEqualFold = data - case "ownerIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.RoleIn = data + case "roleNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNotIn")) + data, err := ec.unmarshalOGroupMembershipHistoryRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } - it.OwnerIDContainsFold = data - case "name": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + it.RoleNotIn = data + case "groupID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Name = data - case "nameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) + it.GroupID = data + case "groupIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameNEQ = data - case "nameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) + it.GroupIDNEQ = data + case "groupIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.NameIn = data - case "nameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) + it.GroupIDIn = data + case "groupIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.NameNotIn = data - case "nameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) + it.GroupIDNotIn = data + case "groupIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameGT = data - case "nameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) + it.GroupIDGT = data + case "groupIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameGTE = data - case "nameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) + it.GroupIDGTE = data + case "groupIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameLT = data - case "nameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) + it.GroupIDLT = data + case "groupIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameLTE = data - case "nameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) + it.GroupIDLTE = data + case "groupIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameContains = data - case "nameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) + it.GroupIDContains = data + case "groupIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameHasPrefix = data - case "nameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) + it.GroupIDHasPrefix = data + case "groupIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameHasSuffix = data - case "nameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) + it.GroupIDHasSuffix = data + case "groupIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameEqualFold = data - case "nameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) + it.GroupIDEqualFold = data + case "groupIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NameContainsFold = data - case "displayName": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayName")) + it.GroupIDContainsFold = data + case "userID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayName = data - case "displayNameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNEQ")) + it.UserID = data + case "userIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameNEQ = data - case "displayNameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIn")) + it.UserIDNEQ = data + case "userIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DisplayNameIn = data - case "displayNameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotIn")) + it.UserIDIn = data + case "userIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DisplayNameNotIn = data - case "displayNameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGT")) + it.UserIDNotIn = data + case "userIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameGT = data - case "displayNameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGTE")) + it.UserIDGT = data + case "userIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameGTE = data - case "displayNameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLT")) + it.UserIDGTE = data + case "userIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameLT = data - case "displayNameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLTE")) + it.UserIDLT = data + case "userIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameLTE = data - case "displayNameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContains")) + it.UserIDLTE = data + case "userIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameContains = data - case "displayNameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasPrefix")) + it.UserIDContains = data + case "userIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameHasPrefix = data - case "displayNameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasSuffix")) + it.UserIDHasPrefix = data + case "userIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameHasSuffix = data - case "displayNameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameEqualFold")) + it.UserIDHasSuffix = data + case "userIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameEqualFold = data - case "displayNameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContainsFold")) + it.UserIDEqualFold = data + case "userIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameContainsFold = data + it.UserIDContainsFold = data } } return it, nil } -func (ec *executionContext) unmarshalInputGroupMembershipHistoryWhereInput(ctx context.Context, obj interface{}) (generated.GroupMembershipHistoryWhereInput, error) { - var it generated.GroupMembershipHistoryWhereInput +func (ec *executionContext) unmarshalInputGroupMembershipWhereInput(ctx context.Context, obj interface{}) (generated.GroupMembershipWhereInput, error) { + var it generated.GroupMembershipWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "role", "roleNEQ", "roleIn", "roleNotIn", "groupID", "groupIDNEQ", "groupIDIn", "groupIDNotIn", "groupIDGT", "groupIDGTE", "groupIDLT", "groupIDLTE", "groupIDContains", "groupIDHasPrefix", "groupIDHasSuffix", "groupIDEqualFold", "groupIDContainsFold", "userID", "userIDNEQ", "userIDIn", "userIDNotIn", "userIDGT", "userIDGTE", "userIDLT", "userIDLTE", "userIDContains", "userIDHasPrefix", "userIDHasSuffix", "userIDEqualFold", "userIDContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "role", "roleNEQ", "roleIn", "roleNotIn", "groupID", "userID"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -281878,21 +288571,21 @@ func (ec *executionContext) unmarshalInputGroupMembershipHistoryWhereInput(ctx c switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOGroupMembershipHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipHistoryWhereInput(ctx, v) + data, err := ec.unmarshalOGroupMembershipWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOGroupMembershipHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOGroupMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOGroupMembershipHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOGroupMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -281967,195 +288660,6 @@ func (ec *executionContext) unmarshalInputGroupMembershipHistoryWhereInput(ctx c return it, err } it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOGroupMembershipHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOGroupMembershipHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOGroupMembershipHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOGroupMembershipHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -282683,28 +289187,28 @@ func (ec *executionContext) unmarshalInputGroupMembershipHistoryWhereInput(ctx c it.DeletedByContainsFold = data case "role": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) - data, err := ec.unmarshalOGroupMembershipHistoryRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + data, err := ec.unmarshalOGroupMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } it.Role = data case "roleNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNEQ")) - data, err := ec.unmarshalOGroupMembershipHistoryRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + data, err := ec.unmarshalOGroupMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } it.RoleNEQ = data case "roleIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleIn")) - data, err := ec.unmarshalOGroupMembershipHistoryRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + data, err := ec.unmarshalOGroupMembershipRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } it.RoleIn = data case "roleNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNotIn")) - data, err := ec.unmarshalOGroupMembershipHistoryRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + data, err := ec.unmarshalOGroupMembershipRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } @@ -282716,292 +289220,351 @@ func (ec *executionContext) unmarshalInputGroupMembershipHistoryWhereInput(ctx c return it, err } it.GroupID = data - case "groupIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNEQ")) + case "userID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.GroupIDNEQ = data - case "groupIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.UserID = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputGroupOrder(ctx context.Context, obj interface{}) (generated.GroupOrder, error) { + var it generated.GroupOrder + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + if _, present := asMap["direction"]; !present { + asMap["direction"] = "ASC" + } + + fieldsInOrder := [...]string{"direction", "field"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "direction": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction")) + data, err := ec.unmarshalNOrderDirection2entgoᚗioᚋcontribᚋentgqlᚐOrderDirection(ctx, v) if err != nil { return it, err } - it.GroupIDIn = data - case "groupIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.Direction = data + case "field": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) + data, err := ec.unmarshalNGroupOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupOrderField(ctx, v) if err != nil { return it, err } - it.GroupIDNotIn = data - case "groupIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Field = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputGroupSettingHistoryWhereInput(ctx context.Context, obj interface{}) (generated.GroupSettingHistoryWhereInput, error) { + var it generated.GroupSettingHistoryWhereInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "visibility", "visibilityNEQ", "visibilityIn", "visibilityNotIn", "joinPolicy", "joinPolicyNEQ", "joinPolicyIn", "joinPolicyNotIn", "syncToSlack", "syncToSlackNEQ", "syncToSlackIsNil", "syncToSlackNotNil", "syncToGithub", "syncToGithubNEQ", "syncToGithubIsNil", "syncToGithubNotNil", "groupID", "groupIDNEQ", "groupIDIn", "groupIDNotIn", "groupIDGT", "groupIDGTE", "groupIDLT", "groupIDLTE", "groupIDContains", "groupIDHasPrefix", "groupIDHasSuffix", "groupIDIsNil", "groupIDNotNil", "groupIDEqualFold", "groupIDContainsFold"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) + data, err := ec.unmarshalOGroupSettingHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingHistoryWhereInput(ctx, v) if err != nil { return it, err } - it.GroupIDGT = data - case "groupIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Not = data + case "and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) + data, err := ec.unmarshalOGroupSettingHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDGTE = data - case "groupIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.And = data + case "or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) + data, err := ec.unmarshalOGroupSettingHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDLT = data - case "groupIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Or = data + case "id": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.GroupIDLTE = data - case "groupIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ID = data + case "idNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.GroupIDContains = data - case "groupIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDNEQ = data + case "idIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDHasPrefix = data - case "groupIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDIn = data + case "idNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDHasSuffix = data - case "groupIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDNotIn = data + case "idGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.GroupIDEqualFold = data - case "groupIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDGT = data + case "idGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.GroupIDContainsFold = data - case "userID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDGTE = data + case "idLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserID = data - case "userIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDLT = data + case "idLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDNEQ = data - case "userIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.IDLTE = data + case "idEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDIn = data - case "userIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.IDEqualFold = data + case "idContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDNotIn = data - case "userIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.UserIDGT = data - case "userIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.UserIDGTE = data - case "userIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.UserIDLT = data - case "userIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.UserIDLTE = data - case "userIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.UserIDContains = data - case "userIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDHasPrefix")) + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDHasPrefix = data - case "userIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDHasSuffix")) + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDHasSuffix = data - case "userIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDEqualFold")) + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDEqualFold = data - case "userIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDContainsFold")) + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDContainsFold = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputGroupMembershipWhereInput(ctx context.Context, obj interface{}) (generated.GroupMembershipWhereInput, error) { - var it generated.GroupMembershipWhereInput - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "role", "roleNEQ", "roleIn", "roleNotIn", "groupID", "userID"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "not": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOGroupMembershipWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInput(ctx, v) + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Not = data - case "and": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOGroupMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInputᚄ(ctx, v) + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.And = data - case "or": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOGroupMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInputᚄ(ctx, v) + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Or = data - case "id": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ID = data - case "idNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDNEQ = data - case "idIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.IDIn = data - case "idNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.IDNotIn = data - case "idGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDGT = data - case "idGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDGTE = data - case "idLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOGroupSettingHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } - it.IDLT = data - case "idLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOGroupSettingHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } - it.IDLTE = data - case "idEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOGroupSettingHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } - it.IDEqualFold = data - case "idContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOGroupSettingHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } - it.IDContainsFold = data + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -283527,34 +290090,118 @@ func (ec *executionContext) unmarshalInputGroupMembershipWhereInput(ctx context. return it, err } it.DeletedByContainsFold = data - case "role": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) - data, err := ec.unmarshalOGroupMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + case "visibility": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibility")) + data, err := ec.unmarshalOGroupSettingHistoryVisibility2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibility(ctx, v) if err != nil { return it, err } - it.Role = data - case "roleNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNEQ")) - data, err := ec.unmarshalOGroupMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + it.Visibility = data + case "visibilityNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibilityNEQ")) + data, err := ec.unmarshalOGroupSettingHistoryVisibility2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibility(ctx, v) if err != nil { return it, err } - it.RoleNEQ = data - case "roleIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleIn")) - data, err := ec.unmarshalOGroupMembershipRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + it.VisibilityNEQ = data + case "visibilityIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibilityIn")) + data, err := ec.unmarshalOGroupSettingHistoryVisibility2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibilityᚄ(ctx, v) if err != nil { return it, err } - it.RoleIn = data - case "roleNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNotIn")) - data, err := ec.unmarshalOGroupMembershipRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + it.VisibilityIn = data + case "visibilityNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibilityNotIn")) + data, err := ec.unmarshalOGroupSettingHistoryVisibility2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibilityᚄ(ctx, v) if err != nil { return it, err } - it.RoleNotIn = data + it.VisibilityNotIn = data + case "joinPolicy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicy")) + data, err := ec.unmarshalOGroupSettingHistoryJoinPolicy2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicy(ctx, v) + if err != nil { + return it, err + } + it.JoinPolicy = data + case "joinPolicyNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicyNEQ")) + data, err := ec.unmarshalOGroupSettingHistoryJoinPolicy2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicy(ctx, v) + if err != nil { + return it, err + } + it.JoinPolicyNEQ = data + case "joinPolicyIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicyIn")) + data, err := ec.unmarshalOGroupSettingHistoryJoinPolicy2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicyᚄ(ctx, v) + if err != nil { + return it, err + } + it.JoinPolicyIn = data + case "joinPolicyNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicyNotIn")) + data, err := ec.unmarshalOGroupSettingHistoryJoinPolicy2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicyᚄ(ctx, v) + if err != nil { + return it, err + } + it.JoinPolicyNotIn = data + case "syncToSlack": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToSlack")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.SyncToSlack = data + case "syncToSlackNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToSlackNEQ")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.SyncToSlackNEQ = data + case "syncToSlackIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToSlackIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.SyncToSlackIsNil = data + case "syncToSlackNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToSlackNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.SyncToSlackNotNil = data + case "syncToGithub": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToGithub")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.SyncToGithub = data + case "syncToGithubNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToGithubNEQ")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.SyncToGithubNEQ = data + case "syncToGithubIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToGithubIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.SyncToGithubIsNil = data + case "syncToGithubNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToGithubNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.SyncToGithubNotNil = data case "groupID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) @@ -283562,65 +290209,118 @@ func (ec *executionContext) unmarshalInputGroupMembershipWhereInput(ctx context. return it, err } it.GroupID = data - case "userID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userID")) + case "groupIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserID = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputGroupOrder(ctx context.Context, obj interface{}) (generated.GroupOrder, error) { - var it generated.GroupOrder - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - if _, present := asMap["direction"]; !present { - asMap["direction"] = "ASC" - } - - fieldsInOrder := [...]string{"direction", "field"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "direction": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction")) - data, err := ec.unmarshalNOrderDirection2entgoᚗioᚋcontribᚋentgqlᚐOrderDirection(ctx, v) + it.GroupIDNEQ = data + case "groupIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.Direction = data - case "field": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) - data, err := ec.unmarshalNGroupOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupOrderField(ctx, v) + it.GroupIDIn = data + case "groupIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.Field = data + it.GroupIDNotIn = data + case "groupIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.GroupIDGT = data + case "groupIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.GroupIDGTE = data + case "groupIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.GroupIDLT = data + case "groupIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.GroupIDLTE = data + case "groupIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.GroupIDContains = data + case "groupIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.GroupIDHasPrefix = data + case "groupIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.GroupIDHasSuffix = data + case "groupIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.GroupIDIsNil = data + case "groupIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.GroupIDNotNil = data + case "groupIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.GroupIDEqualFold = data + case "groupIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.GroupIDContainsFold = data } } return it, nil } -func (ec *executionContext) unmarshalInputGroupSettingHistoryWhereInput(ctx context.Context, obj interface{}) (generated.GroupSettingHistoryWhereInput, error) { - var it generated.GroupSettingHistoryWhereInput +func (ec *executionContext) unmarshalInputGroupSettingWhereInput(ctx context.Context, obj interface{}) (generated.GroupSettingWhereInput, error) { + var it generated.GroupSettingWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "visibility", "visibilityNEQ", "visibilityIn", "visibilityNotIn", "joinPolicy", "joinPolicyNEQ", "joinPolicyIn", "joinPolicyNotIn", "syncToSlack", "syncToSlackNEQ", "syncToSlackIsNil", "syncToSlackNotNil", "syncToGithub", "syncToGithubNEQ", "syncToGithubIsNil", "syncToGithubNotNil", "groupID", "groupIDNEQ", "groupIDIn", "groupIDNotIn", "groupIDGT", "groupIDGTE", "groupIDLT", "groupIDLTE", "groupIDContains", "groupIDHasPrefix", "groupIDHasSuffix", "groupIDIsNil", "groupIDNotNil", "groupIDEqualFold", "groupIDContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "visibility", "visibilityNEQ", "visibilityIn", "visibilityNotIn", "joinPolicy", "joinPolicyNEQ", "joinPolicyIn", "joinPolicyNotIn", "syncToSlack", "syncToSlackNEQ", "syncToSlackIsNil", "syncToSlackNotNil", "syncToGithub", "syncToGithubNEQ", "syncToGithubIsNil", "syncToGithubNotNil", "groupID", "groupIDNEQ", "groupIDIn", "groupIDNotIn", "groupIDGT", "groupIDGTE", "groupIDLT", "groupIDLTE", "groupIDContains", "groupIDHasPrefix", "groupIDHasSuffix", "groupIDIsNil", "groupIDNotNil", "groupIDEqualFold", "groupIDContainsFold", "hasGroup", "hasGroupWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -283629,21 +290329,21 @@ func (ec *executionContext) unmarshalInputGroupSettingHistoryWhereInput(ctx cont switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOGroupSettingHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingHistoryWhereInput(ctx, v) + data, err := ec.unmarshalOGroupSettingWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOGroupSettingHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOGroupSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOGroupSettingHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOGroupSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -283718,195 +290418,6 @@ func (ec *executionContext) unmarshalInputGroupSettingHistoryWhereInput(ctx cont return it, err } it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOGroupSettingHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOGroupSettingHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOGroupSettingHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOGroupSettingHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -284434,56 +290945,56 @@ func (ec *executionContext) unmarshalInputGroupSettingHistoryWhereInput(ctx cont it.DeletedByContainsFold = data case "visibility": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibility")) - data, err := ec.unmarshalOGroupSettingHistoryVisibility2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibility(ctx, v) + data, err := ec.unmarshalOGroupSettingVisibility2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibility(ctx, v) if err != nil { return it, err } it.Visibility = data case "visibilityNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibilityNEQ")) - data, err := ec.unmarshalOGroupSettingHistoryVisibility2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibility(ctx, v) + data, err := ec.unmarshalOGroupSettingVisibility2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibility(ctx, v) if err != nil { return it, err } it.VisibilityNEQ = data case "visibilityIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibilityIn")) - data, err := ec.unmarshalOGroupSettingHistoryVisibility2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibilityᚄ(ctx, v) + data, err := ec.unmarshalOGroupSettingVisibility2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibilityᚄ(ctx, v) if err != nil { return it, err } it.VisibilityIn = data case "visibilityNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibilityNotIn")) - data, err := ec.unmarshalOGroupSettingHistoryVisibility2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibilityᚄ(ctx, v) + data, err := ec.unmarshalOGroupSettingVisibility2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibilityᚄ(ctx, v) if err != nil { return it, err } it.VisibilityNotIn = data case "joinPolicy": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicy")) - data, err := ec.unmarshalOGroupSettingHistoryJoinPolicy2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicy(ctx, v) + data, err := ec.unmarshalOGroupSettingJoinPolicy2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicy(ctx, v) if err != nil { return it, err } it.JoinPolicy = data case "joinPolicyNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicyNEQ")) - data, err := ec.unmarshalOGroupSettingHistoryJoinPolicy2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicy(ctx, v) + data, err := ec.unmarshalOGroupSettingJoinPolicy2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicy(ctx, v) if err != nil { return it, err } it.JoinPolicyNEQ = data case "joinPolicyIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicyIn")) - data, err := ec.unmarshalOGroupSettingHistoryJoinPolicy2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicyᚄ(ctx, v) + data, err := ec.unmarshalOGroupSettingJoinPolicy2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicyᚄ(ctx, v) if err != nil { return it, err } it.JoinPolicyIn = data case "joinPolicyNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicyNotIn")) - data, err := ec.unmarshalOGroupSettingHistoryJoinPolicy2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicyᚄ(ctx, v) + data, err := ec.unmarshalOGroupSettingJoinPolicy2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicyᚄ(ctx, v) if err != nil { return it, err } @@ -284546,77 +291057,77 @@ func (ec *executionContext) unmarshalInputGroupSettingHistoryWhereInput(ctx cont it.SyncToGithubNotNil = data case "groupID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupID = data case "groupIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupIDNEQ = data case "groupIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.GroupIDIn = data case "groupIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.GroupIDNotIn = data case "groupIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupIDGT = data case "groupIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupIDGTE = data case "groupIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupIDLT = data case "groupIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupIDLTE = data case "groupIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupIDContains = data case "groupIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupIDHasPrefix = data case "groupIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -284637,32 +291148,46 @@ func (ec *executionContext) unmarshalInputGroupSettingHistoryWhereInput(ctx cont it.GroupIDNotNil = data case "groupIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupIDEqualFold = data case "groupIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.GroupIDContainsFold = data + case "hasGroup": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroup")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasGroup = data + case "hasGroupWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupWith")) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasGroupWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputGroupSettingWhereInput(ctx context.Context, obj interface{}) (generated.GroupSettingWhereInput, error) { - var it generated.GroupSettingWhereInput +func (ec *executionContext) unmarshalInputGroupWhereInput(ctx context.Context, obj interface{}) (generated.GroupWhereInput, error) { + var it generated.GroupWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "visibility", "visibilityNEQ", "visibilityIn", "visibilityNotIn", "joinPolicy", "joinPolicyNEQ", "joinPolicyIn", "joinPolicyNotIn", "syncToSlack", "syncToSlackNEQ", "syncToSlackIsNil", "syncToSlackNotNil", "syncToGithub", "syncToGithubNEQ", "syncToGithubIsNil", "syncToGithubNotNil", "groupID", "groupIDNEQ", "groupIDIn", "groupIDNotIn", "groupIDGT", "groupIDGTE", "groupIDLT", "groupIDLTE", "groupIDContains", "groupIDHasPrefix", "groupIDHasSuffix", "groupIDIsNil", "groupIDNotNil", "groupIDEqualFold", "groupIDContainsFold", "hasGroup", "hasGroupWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameEqualFold", "displayNameContainsFold", "hasOwner", "hasOwnerWith", "hasControlCreators", "hasControlCreatorsWith", "hasControlObjectiveCreators", "hasControlObjectiveCreatorsWith", "hasGroupCreators", "hasGroupCreatorsWith", "hasInternalPolicyCreators", "hasInternalPolicyCreatorsWith", "hasNarrativeCreators", "hasNarrativeCreatorsWith", "hasProcedureCreators", "hasProcedureCreatorsWith", "hasProgramCreators", "hasProgramCreatorsWith", "hasRiskCreators", "hasRiskCreatorsWith", "hasTemplateCreators", "hasTemplateCreatorsWith", "hasProcedureEditors", "hasProcedureEditorsWith", "hasProcedureBlockedGroups", "hasProcedureBlockedGroupsWith", "hasInternalpolicyEditors", "hasInternalpolicyEditorsWith", "hasInternalpolicyBlockedGroups", "hasInternalpolicyBlockedGroupsWith", "hasProgramEditors", "hasProgramEditorsWith", "hasProgramBlockedGroups", "hasProgramBlockedGroupsWith", "hasProgramViewers", "hasProgramViewersWith", "hasRiskEditors", "hasRiskEditorsWith", "hasRiskBlockedGroups", "hasRiskBlockedGroupsWith", "hasRiskViewers", "hasRiskViewersWith", "hasControlobjectiveEditors", "hasControlobjectiveEditorsWith", "hasControlobjectiveBlockedGroups", "hasControlobjectiveBlockedGroupsWith", "hasControlobjectiveViewers", "hasControlobjectiveViewersWith", "hasControlEditors", "hasControlEditorsWith", "hasControlBlockedGroups", "hasControlBlockedGroupsWith", "hasControlViewers", "hasControlViewersWith", "hasNarrativeEditors", "hasNarrativeEditorsWith", "hasNarrativeBlockedGroups", "hasNarrativeBlockedGroupsWith", "hasNarrativeViewers", "hasNarrativeViewersWith", "hasSetting", "hasSettingWith", "hasUsers", "hasUsersWith", "hasEvents", "hasEventsWith", "hasIntegrations", "hasIntegrationsWith", "hasFiles", "hasFilesWith", "hasTasks", "hasTasksWith", "hasMembers", "hasMembersWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -284671,21 +291196,21 @@ func (ec *executionContext) unmarshalInputGroupSettingWhereInput(ctx context.Con switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOGroupSettingWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingWhereInput(ctx, v) + data, err := ec.unmarshalOGroupWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOGroupSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOGroupSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -285285,251 +291810,849 @@ func (ec *executionContext) unmarshalInputGroupSettingWhereInput(ctx context.Con return it, err } it.DeletedByContainsFold = data - case "visibility": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibility")) - data, err := ec.unmarshalOGroupSettingVisibility2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibility(ctx, v) + case "ownerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.Visibility = data - case "visibilityNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibilityNEQ")) - data, err := ec.unmarshalOGroupSettingVisibility2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibility(ctx, v) + it.OwnerID = data + case "ownerIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.VisibilityNEQ = data - case "visibilityIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibilityIn")) - data, err := ec.unmarshalOGroupSettingVisibility2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibilityᚄ(ctx, v) + it.OwnerIDNEQ = data + case "ownerIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.VisibilityIn = data - case "visibilityNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("visibilityNotIn")) - data, err := ec.unmarshalOGroupSettingVisibility2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐVisibilityᚄ(ctx, v) + it.OwnerIDIn = data + case "ownerIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.VisibilityNotIn = data - case "joinPolicy": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicy")) - data, err := ec.unmarshalOGroupSettingJoinPolicy2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicy(ctx, v) + it.OwnerIDNotIn = data + case "ownerIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.JoinPolicy = data - case "joinPolicyNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicyNEQ")) - data, err := ec.unmarshalOGroupSettingJoinPolicy2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicy(ctx, v) + it.OwnerIDGT = data + case "ownerIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.JoinPolicyNEQ = data - case "joinPolicyIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicyIn")) - data, err := ec.unmarshalOGroupSettingJoinPolicy2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicyᚄ(ctx, v) + it.OwnerIDGTE = data + case "ownerIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.JoinPolicyIn = data - case "joinPolicyNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("joinPolicyNotIn")) - data, err := ec.unmarshalOGroupSettingJoinPolicy2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐJoinPolicyᚄ(ctx, v) + it.OwnerIDLT = data + case "ownerIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.JoinPolicyNotIn = data - case "syncToSlack": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToSlack")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.OwnerIDLTE = data + case "ownerIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.SyncToSlack = data - case "syncToSlackNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToSlackNEQ")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.OwnerIDContains = data + case "ownerIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.SyncToSlackNEQ = data - case "syncToSlackIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToSlackIsNil")) + it.OwnerIDHasPrefix = data + case "ownerIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDHasSuffix = data + case "ownerIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.SyncToSlackIsNil = data - case "syncToSlackNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToSlackNotNil")) + it.OwnerIDIsNil = data + case "ownerIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.SyncToSlackNotNil = data - case "syncToGithub": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToGithub")) + it.OwnerIDNotNil = data + case "ownerIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDEqualFold = data + case "ownerIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDContainsFold = data + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "nameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameNEQ = data + case "nameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.NameIn = data + case "nameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.NameNotIn = data + case "nameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameGT = data + case "nameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameGTE = data + case "nameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameLT = data + case "nameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameLTE = data + case "nameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameContains = data + case "nameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameHasPrefix = data + case "nameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameHasSuffix = data + case "nameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameEqualFold = data + case "nameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NameContainsFold = data + case "displayName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayName")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayName = data + case "displayNameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameNEQ = data + case "displayNameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameIn = data + case "displayNameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameNotIn = data + case "displayNameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameGT = data + case "displayNameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameGTE = data + case "displayNameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameLT = data + case "displayNameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameLTE = data + case "displayNameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameContains = data + case "displayNameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameHasPrefix = data + case "displayNameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameHasSuffix = data + case "displayNameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameEqualFold = data + case "displayNameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.DisplayNameContainsFold = data + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.SyncToGithub = data - case "syncToGithubNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToGithubNEQ")) + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOwnerWith = data + case "hasControlCreators": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlCreators")) data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.SyncToGithubNEQ = data - case "syncToGithubIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToGithubIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.HasControlCreators = data + case "hasControlCreatorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlCreatorsWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.SyncToGithubIsNil = data - case "syncToGithubNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("syncToGithubNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.HasControlCreatorsWith = data + case "hasControlObjectiveCreators": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlObjectiveCreators")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.SyncToGithubNotNil = data - case "groupID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasControlObjectiveCreators = data + case "hasControlObjectiveCreatorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlObjectiveCreatorsWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.GroupID = data - case "groupIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasControlObjectiveCreatorsWith = data + case "hasGroupCreators": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupCreators")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.GroupIDNEQ = data - case "groupIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.HasGroupCreators = data + case "hasGroupCreatorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupCreatorsWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDIn = data - case "groupIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.HasGroupCreatorsWith = data + case "hasInternalPolicyCreators": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalPolicyCreators")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.GroupIDNotIn = data - case "groupIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasInternalPolicyCreators = data + case "hasInternalPolicyCreatorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalPolicyCreatorsWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDGT = data - case "groupIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasInternalPolicyCreatorsWith = data + case "hasNarrativeCreators": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeCreators")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.GroupIDGTE = data - case "groupIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasNarrativeCreators = data + case "hasNarrativeCreatorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeCreatorsWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDLT = data - case "groupIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasNarrativeCreatorsWith = data + case "hasProcedureCreators": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureCreators")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.GroupIDLTE = data - case "groupIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContains")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasProcedureCreators = data + case "hasProcedureCreatorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureCreatorsWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProcedureCreatorsWith = data + case "hasProgramCreators": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramCreators")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasProgramCreators = data + case "hasProgramCreatorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramCreatorsWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProgramCreatorsWith = data + case "hasRiskCreators": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskCreators")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasRiskCreators = data + case "hasRiskCreatorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskCreatorsWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasRiskCreatorsWith = data + case "hasTemplateCreators": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTemplateCreators")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasTemplateCreators = data + case "hasTemplateCreatorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTemplateCreatorsWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasTemplateCreatorsWith = data + case "hasProcedureEditors": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureEditors")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasProcedureEditors = data + case "hasProcedureEditorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureEditorsWith")) + data, err := ec.unmarshalOProcedureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProcedureEditorsWith = data + case "hasProcedureBlockedGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureBlockedGroups")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasProcedureBlockedGroups = data + case "hasProcedureBlockedGroupsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureBlockedGroupsWith")) + data, err := ec.unmarshalOProcedureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProcedureBlockedGroupsWith = data + case "hasInternalpolicyEditors": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalpolicyEditors")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasInternalpolicyEditors = data + case "hasInternalpolicyEditorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalpolicyEditorsWith")) + data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasInternalpolicyEditorsWith = data + case "hasInternalpolicyBlockedGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalpolicyBlockedGroups")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasInternalpolicyBlockedGroups = data + case "hasInternalpolicyBlockedGroupsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalpolicyBlockedGroupsWith")) + data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasInternalpolicyBlockedGroupsWith = data + case "hasProgramEditors": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramEditors")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasProgramEditors = data + case "hasProgramEditorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramEditorsWith")) + data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProgramEditorsWith = data + case "hasProgramBlockedGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramBlockedGroups")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasProgramBlockedGroups = data + case "hasProgramBlockedGroupsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramBlockedGroupsWith")) + data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProgramBlockedGroupsWith = data + case "hasProgramViewers": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramViewers")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasProgramViewers = data + case "hasProgramViewersWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramViewersWith")) + data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProgramViewersWith = data + case "hasRiskEditors": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskEditors")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasRiskEditors = data + case "hasRiskEditorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskEditorsWith")) + data, err := ec.unmarshalORiskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasRiskEditorsWith = data + case "hasRiskBlockedGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskBlockedGroups")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasRiskBlockedGroups = data + case "hasRiskBlockedGroupsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskBlockedGroupsWith")) + data, err := ec.unmarshalORiskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasRiskBlockedGroupsWith = data + case "hasRiskViewers": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskViewers")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasRiskViewers = data + case "hasRiskViewersWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskViewersWith")) + data, err := ec.unmarshalORiskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasRiskViewersWith = data + case "hasControlobjectiveEditors": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveEditors")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjectiveEditors = data + case "hasControlobjectiveEditorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveEditorsWith")) + data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjectiveEditorsWith = data + case "hasControlobjectiveBlockedGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveBlockedGroups")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjectiveBlockedGroups = data + case "hasControlobjectiveBlockedGroupsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveBlockedGroupsWith")) + data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjectiveBlockedGroupsWith = data + case "hasControlobjectiveViewers": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveViewers")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjectiveViewers = data + case "hasControlobjectiveViewersWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveViewersWith")) + data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjectiveViewersWith = data + case "hasControlEditors": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlEditors")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControlEditors = data + case "hasControlEditorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlEditorsWith")) + data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlEditorsWith = data + case "hasControlBlockedGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlBlockedGroups")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControlBlockedGroups = data + case "hasControlBlockedGroupsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlBlockedGroupsWith")) + data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlBlockedGroupsWith = data + case "hasControlViewers": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlViewers")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControlViewers = data + case "hasControlViewersWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlViewersWith")) + data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlViewersWith = data + case "hasNarrativeEditors": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeEditors")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasNarrativeEditors = data + case "hasNarrativeEditorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeEditorsWith")) + data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasNarrativeEditorsWith = data + case "hasNarrativeBlockedGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeBlockedGroups")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasNarrativeBlockedGroups = data + case "hasNarrativeBlockedGroupsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeBlockedGroupsWith")) + data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasNarrativeBlockedGroupsWith = data + case "hasNarrativeViewers": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeViewers")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasNarrativeViewers = data + case "hasNarrativeViewersWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeViewersWith")) + data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasNarrativeViewersWith = data + case "hasSetting": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSetting")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasSetting = data + case "hasSettingWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSettingWith")) + data, err := ec.unmarshalOGroupSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasSettingWith = data + case "hasUsers": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUsers")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasUsers = data + case "hasUsersWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUsersWith")) + data, err := ec.unmarshalOUserWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasUsersWith = data + case "hasEvents": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEvents = data + case "hasEventsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) + data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEventsWith = data + case "hasIntegrations": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrations")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.GroupIDContains = data - case "groupIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasPrefix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasIntegrations = data + case "hasIntegrationsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrationsWith")) + data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDHasPrefix = data - case "groupIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDHasSuffix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasIntegrationsWith = data + case "hasFiles": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFiles")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.GroupIDHasSuffix = data - case "groupIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.HasFiles = data + case "hasFilesWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFilesWith")) + data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDIsNil = data - case "groupIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.HasFilesWith = data + case "hasTasks": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTasks")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.GroupIDNotNil = data - case "groupIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasTasks = data + case "hasTasksWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTasksWith")) + data, err := ec.unmarshalOTaskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.GroupIDEqualFold = data - case "groupIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupIDContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.HasTasksWith = data + case "hasMembers": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasMembers")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.GroupIDContainsFold = data - case "hasGroup": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroup")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.HasMembers = data + case "hasMembersWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasMembersWith")) + data, err := ec.unmarshalOGroupMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.HasGroup = data - case "hasGroupWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupWith")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + it.HasMembersWith = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputHushHistoryOrder(ctx context.Context, obj interface{}) (generated.HushHistoryOrder, error) { + var it generated.HushHistoryOrder + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + if _, present := asMap["direction"]; !present { + asMap["direction"] = "ASC" + } + + fieldsInOrder := [...]string{"direction", "field"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "direction": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction")) + data, err := ec.unmarshalNOrderDirection2entgoᚗioᚋcontribᚋentgqlᚐOrderDirection(ctx, v) if err != nil { return it, err } - it.HasGroupWith = data + it.Direction = data + case "field": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) + data, err := ec.unmarshalNHushHistoryOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushHistoryOrderField(ctx, v) + if err != nil { + return it, err + } + it.Field = data } } return it, nil } -func (ec *executionContext) unmarshalInputGroupWhereInput(ctx context.Context, obj interface{}) (generated.GroupWhereInput, error) { - var it generated.GroupWhereInput +func (ec *executionContext) unmarshalInputHushHistoryWhereInput(ctx context.Context, obj interface{}) (generated.HushHistoryWhereInput, error) { + var it generated.HushHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameEqualFold", "displayNameContainsFold", "hasOwner", "hasOwnerWith", "hasControlCreators", "hasControlCreatorsWith", "hasControlObjectiveCreators", "hasControlObjectiveCreatorsWith", "hasGroupCreators", "hasGroupCreatorsWith", "hasInternalPolicyCreators", "hasInternalPolicyCreatorsWith", "hasNarrativeCreators", "hasNarrativeCreatorsWith", "hasProcedureCreators", "hasProcedureCreatorsWith", "hasProgramCreators", "hasProgramCreatorsWith", "hasRiskCreators", "hasRiskCreatorsWith", "hasTemplateCreators", "hasTemplateCreatorsWith", "hasProcedureEditors", "hasProcedureEditorsWith", "hasProcedureBlockedGroups", "hasProcedureBlockedGroupsWith", "hasInternalpolicyEditors", "hasInternalpolicyEditorsWith", "hasInternalpolicyBlockedGroups", "hasInternalpolicyBlockedGroupsWith", "hasProgramEditors", "hasProgramEditorsWith", "hasProgramBlockedGroups", "hasProgramBlockedGroupsWith", "hasProgramViewers", "hasProgramViewersWith", "hasRiskEditors", "hasRiskEditorsWith", "hasRiskBlockedGroups", "hasRiskBlockedGroupsWith", "hasRiskViewers", "hasRiskViewersWith", "hasControlobjectiveEditors", "hasControlobjectiveEditorsWith", "hasControlobjectiveBlockedGroups", "hasControlobjectiveBlockedGroupsWith", "hasControlobjectiveViewers", "hasControlobjectiveViewersWith", "hasControlEditors", "hasControlEditorsWith", "hasControlBlockedGroups", "hasControlBlockedGroupsWith", "hasControlViewers", "hasControlViewersWith", "hasNarrativeEditors", "hasNarrativeEditorsWith", "hasNarrativeBlockedGroups", "hasNarrativeBlockedGroupsWith", "hasNarrativeViewers", "hasNarrativeViewersWith", "hasSetting", "hasSettingWith", "hasUsers", "hasUsersWith", "hasEvents", "hasEventsWith", "hasIntegrations", "hasIntegrationsWith", "hasFiles", "hasFilesWith", "hasTasks", "hasTasksWith", "hasMembers", "hasMembersWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "kind", "kindNEQ", "kindIn", "kindNotIn", "kindGT", "kindGTE", "kindLT", "kindLTE", "kindContains", "kindHasPrefix", "kindHasSuffix", "kindIsNil", "kindNotNil", "kindEqualFold", "kindContainsFold", "secretName", "secretNameNEQ", "secretNameIn", "secretNameNotIn", "secretNameGT", "secretNameGTE", "secretNameLT", "secretNameLTE", "secretNameContains", "secretNameHasPrefix", "secretNameHasSuffix", "secretNameIsNil", "secretNameNotNil", "secretNameEqualFold", "secretNameContainsFold"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -285538,21 +292661,21 @@ func (ec *executionContext) unmarshalInputGroupWhereInput(ctx context.Context, o switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOGroupWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInput(ctx, v) + data, err := ec.unmarshalOHushHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOHushHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOHushHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -285627,6 +292750,195 @@ func (ec *executionContext) unmarshalInputGroupWhereInput(ctx context.Context, o return it, err } it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOHushHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOHushHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOHushHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOHushHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -286152,111 +293464,6 @@ func (ec *executionContext) unmarshalInputGroupWhereInput(ctx context.Context, o return it, err } it.DeletedByContainsFold = data - case "ownerID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerID = data - case "ownerIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDNEQ = data - case "ownerIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDIn = data - case "ownerIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDNotIn = data - case "ownerIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDGT = data - case "ownerIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDGTE = data - case "ownerIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDLT = data - case "ownerIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDLTE = data - case "ownerIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDContains = data - case "ownerIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDHasPrefix = data - case "ownerIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDHasSuffix = data - case "ownerIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDIsNil = data - case "ownerIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDNotNil = data - case "ownerIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDEqualFold = data - case "ownerIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDContainsFold = data case "name": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) @@ -286348,609 +293555,224 @@ func (ec *executionContext) unmarshalInputGroupWhereInput(ctx context.Context, o return it, err } it.NameContainsFold = data - case "displayName": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayName")) + case "kind": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kind")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayName = data - case "displayNameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNEQ")) + it.Kind = data + case "kindNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameNEQ = data - case "displayNameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameIn")) + it.KindNEQ = data + case "kindIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DisplayNameIn = data - case "displayNameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameNotIn")) + it.KindIn = data + case "kindNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DisplayNameNotIn = data - case "displayNameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DisplayNameGT = data - case "displayNameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DisplayNameGTE = data - case "displayNameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLT")) + it.KindNotIn = data + case "kindGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameLT = data - case "displayNameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameLTE")) + it.KindGT = data + case "kindGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameLTE = data - case "displayNameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContains")) + it.KindGTE = data + case "kindLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameContains = data - case "displayNameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasPrefix")) + it.KindLT = data + case "kindLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameHasPrefix = data - case "displayNameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameHasSuffix")) + it.KindLTE = data + case "kindContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameHasSuffix = data - case "displayNameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameEqualFold")) + it.KindContains = data + case "kindHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameEqualFold = data - case "displayNameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("displayNameContainsFold")) + it.KindHasPrefix = data + case "kindHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DisplayNameContainsFold = data - case "hasOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasOwner = data - case "hasOwnerWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasOwnerWith = data - case "hasControlCreators": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlCreators")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControlCreators = data - case "hasControlCreatorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlCreatorsWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlCreatorsWith = data - case "hasControlObjectiveCreators": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlObjectiveCreators")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControlObjectiveCreators = data - case "hasControlObjectiveCreatorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlObjectiveCreatorsWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlObjectiveCreatorsWith = data - case "hasGroupCreators": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupCreators")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasGroupCreators = data - case "hasGroupCreatorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasGroupCreatorsWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasGroupCreatorsWith = data - case "hasInternalPolicyCreators": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalPolicyCreators")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasInternalPolicyCreators = data - case "hasInternalPolicyCreatorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalPolicyCreatorsWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasInternalPolicyCreatorsWith = data - case "hasNarrativeCreators": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeCreators")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasNarrativeCreators = data - case "hasNarrativeCreatorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeCreatorsWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasNarrativeCreatorsWith = data - case "hasProcedureCreators": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureCreators")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasProcedureCreators = data - case "hasProcedureCreatorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureCreatorsWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasProcedureCreatorsWith = data - case "hasProgramCreators": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramCreators")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasProgramCreators = data - case "hasProgramCreatorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramCreatorsWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasProgramCreatorsWith = data - case "hasRiskCreators": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskCreators")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasRiskCreators = data - case "hasRiskCreatorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskCreatorsWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasRiskCreatorsWith = data - case "hasTemplateCreators": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTemplateCreators")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasTemplateCreators = data - case "hasTemplateCreatorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTemplateCreatorsWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasTemplateCreatorsWith = data - case "hasProcedureEditors": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureEditors")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasProcedureEditors = data - case "hasProcedureEditorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureEditorsWith")) - data, err := ec.unmarshalOProcedureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasProcedureEditorsWith = data - case "hasProcedureBlockedGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureBlockedGroups")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasProcedureBlockedGroups = data - case "hasProcedureBlockedGroupsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureBlockedGroupsWith")) - data, err := ec.unmarshalOProcedureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasProcedureBlockedGroupsWith = data - case "hasInternalpolicyEditors": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalpolicyEditors")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasInternalpolicyEditors = data - case "hasInternalpolicyEditorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalpolicyEditorsWith")) - data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasInternalpolicyEditorsWith = data - case "hasInternalpolicyBlockedGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalpolicyBlockedGroups")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasInternalpolicyBlockedGroups = data - case "hasInternalpolicyBlockedGroupsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasInternalpolicyBlockedGroupsWith")) - data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasInternalpolicyBlockedGroupsWith = data - case "hasProgramEditors": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramEditors")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasProgramEditors = data - case "hasProgramEditorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramEditorsWith")) - data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasProgramEditorsWith = data - case "hasProgramBlockedGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramBlockedGroups")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasProgramBlockedGroups = data - case "hasProgramBlockedGroupsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramBlockedGroupsWith")) - data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasProgramBlockedGroupsWith = data - case "hasProgramViewers": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramViewers")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasProgramViewers = data - case "hasProgramViewersWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramViewersWith")) - data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasProgramViewersWith = data - case "hasRiskEditors": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskEditors")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasRiskEditors = data - case "hasRiskEditorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskEditorsWith")) - data, err := ec.unmarshalORiskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasRiskEditorsWith = data - case "hasRiskBlockedGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskBlockedGroups")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasRiskBlockedGroups = data - case "hasRiskBlockedGroupsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskBlockedGroupsWith")) - data, err := ec.unmarshalORiskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasRiskBlockedGroupsWith = data - case "hasRiskViewers": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskViewers")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasRiskViewers = data - case "hasRiskViewersWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasRiskViewersWith")) - data, err := ec.unmarshalORiskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐRiskWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasRiskViewersWith = data - case "hasControlobjectiveEditors": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveEditors")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControlobjectiveEditors = data - case "hasControlobjectiveEditorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveEditorsWith")) - data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlobjectiveEditorsWith = data - case "hasControlobjectiveBlockedGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveBlockedGroups")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControlobjectiveBlockedGroups = data - case "hasControlobjectiveBlockedGroupsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveBlockedGroupsWith")) - data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlobjectiveBlockedGroupsWith = data - case "hasControlobjectiveViewers": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveViewers")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControlobjectiveViewers = data - case "hasControlobjectiveViewersWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveViewersWith")) - data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlobjectiveViewersWith = data - case "hasControlEditors": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlEditors")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControlEditors = data - case "hasControlEditorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlEditorsWith")) - data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlEditorsWith = data - case "hasControlBlockedGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlBlockedGroups")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControlBlockedGroups = data - case "hasControlBlockedGroupsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlBlockedGroupsWith")) - data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlBlockedGroupsWith = data - case "hasControlViewers": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlViewers")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControlViewers = data - case "hasControlViewersWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlViewersWith")) - data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlViewersWith = data - case "hasNarrativeEditors": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeEditors")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasNarrativeEditors = data - case "hasNarrativeEditorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeEditorsWith")) - data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + it.KindHasSuffix = data + case "kindIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasNarrativeEditorsWith = data - case "hasNarrativeBlockedGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeBlockedGroups")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.KindIsNil = data + case "kindNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasNarrativeBlockedGroups = data - case "hasNarrativeBlockedGroupsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeBlockedGroupsWith")) - data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + it.KindNotNil = data + case "kindEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasNarrativeBlockedGroupsWith = data - case "hasNarrativeViewers": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeViewers")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.KindEqualFold = data + case "kindContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasNarrativeViewers = data - case "hasNarrativeViewersWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativeViewersWith")) - data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + it.KindContainsFold = data + case "secretName": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretName")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasNarrativeViewersWith = data - case "hasSetting": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSetting")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.SecretName = data + case "secretNameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasSetting = data - case "hasSettingWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSettingWith")) - data, err := ec.unmarshalOGroupSettingWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupSettingWhereInputᚄ(ctx, v) + it.SecretNameNEQ = data + case "secretNameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasSettingWith = data - case "hasUsers": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUsers")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.SecretNameIn = data + case "secretNameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasUsers = data - case "hasUsersWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasUsersWith")) - data, err := ec.unmarshalOUserWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUserWhereInputᚄ(ctx, v) + it.SecretNameNotIn = data + case "secretNameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasUsersWith = data - case "hasEvents": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.SecretNameGT = data + case "secretNameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEvents = data - case "hasEventsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) - data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + it.SecretNameGTE = data + case "secretNameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEventsWith = data - case "hasIntegrations": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrations")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.SecretNameLT = data + case "secretNameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasIntegrations = data - case "hasIntegrationsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrationsWith")) - data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) + it.SecretNameLTE = data + case "secretNameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasIntegrationsWith = data - case "hasFiles": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFiles")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.SecretNameContains = data + case "secretNameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasFiles = data - case "hasFilesWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasFilesWith")) - data, err := ec.unmarshalOFileWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐFileWhereInputᚄ(ctx, v) + it.SecretNameHasPrefix = data + case "secretNameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasFilesWith = data - case "hasTasks": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTasks")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.SecretNameHasSuffix = data + case "secretNameIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasTasks = data - case "hasTasksWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTasksWith")) - data, err := ec.unmarshalOTaskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskWhereInputᚄ(ctx, v) + it.SecretNameIsNil = data + case "secretNameNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasTasksWith = data - case "hasMembers": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasMembers")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.SecretNameNotNil = data + case "secretNameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasMembers = data - case "hasMembersWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasMembersWith")) - data, err := ec.unmarshalOGroupMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupMembershipWhereInputᚄ(ctx, v) + it.SecretNameEqualFold = data + case "secretNameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasMembersWith = data + it.SecretNameContainsFold = data } } return it, nil } -func (ec *executionContext) unmarshalInputHushHistoryOrder(ctx context.Context, obj interface{}) (generated.HushHistoryOrder, error) { - var it generated.HushHistoryOrder +func (ec *executionContext) unmarshalInputHushOrder(ctx context.Context, obj interface{}) (generated.HushOrder, error) { + var it generated.HushOrder asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v @@ -286976,7 +293798,7 @@ func (ec *executionContext) unmarshalInputHushHistoryOrder(ctx context.Context, it.Direction = data case "field": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) - data, err := ec.unmarshalNHushHistoryOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushHistoryOrderField(ctx, v) + data, err := ec.unmarshalNHushOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushOrderField(ctx, v) if err != nil { return it, err } @@ -286987,14 +293809,14 @@ func (ec *executionContext) unmarshalInputHushHistoryOrder(ctx context.Context, return it, nil } -func (ec *executionContext) unmarshalInputHushHistoryWhereInput(ctx context.Context, obj interface{}) (generated.HushHistoryWhereInput, error) { - var it generated.HushHistoryWhereInput +func (ec *executionContext) unmarshalInputHushWhereInput(ctx context.Context, obj interface{}) (generated.HushWhereInput, error) { + var it generated.HushWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "kind", "kindNEQ", "kindIn", "kindNotIn", "kindGT", "kindGTE", "kindLT", "kindLTE", "kindContains", "kindHasPrefix", "kindHasSuffix", "kindIsNil", "kindNotNil", "kindEqualFold", "kindContainsFold", "secretName", "secretNameNEQ", "secretNameIn", "secretNameNotIn", "secretNameGT", "secretNameGTE", "secretNameLT", "secretNameLTE", "secretNameContains", "secretNameHasPrefix", "secretNameHasSuffix", "secretNameIsNil", "secretNameNotNil", "secretNameEqualFold", "secretNameContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "kind", "kindNEQ", "kindIn", "kindNotIn", "kindGT", "kindGTE", "kindLT", "kindLTE", "kindContains", "kindHasPrefix", "kindHasSuffix", "kindIsNil", "kindNotNil", "kindEqualFold", "kindContainsFold", "secretName", "secretNameNEQ", "secretNameIn", "secretNameNotIn", "secretNameGT", "secretNameGTE", "secretNameLT", "secretNameLTE", "secretNameContains", "secretNameHasPrefix", "secretNameHasSuffix", "secretNameIsNil", "secretNameNotNil", "secretNameEqualFold", "secretNameContainsFold", "hasIntegrations", "hasIntegrationsWith", "hasOrganization", "hasOrganizationWith", "hasEvents", "hasEventsWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -287003,21 +293825,21 @@ func (ec *executionContext) unmarshalInputHushHistoryWhereInput(ctx context.Cont switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOHushHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushHistoryWhereInput(ctx, v) + data, err := ec.unmarshalOHushWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOHushHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOHushWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOHushHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOHushWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -287092,195 +293914,6 @@ func (ec *executionContext) unmarshalInputHushHistoryWhereInput(ctx context.Cont return it, err } it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOHushHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOHushHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOHushHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOHushHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -288107,14 +294740,56 @@ func (ec *executionContext) unmarshalInputHushHistoryWhereInput(ctx context.Cont return it, err } it.SecretNameContainsFold = data + case "hasIntegrations": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrations")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasIntegrations = data + case "hasIntegrationsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrationsWith")) + data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasIntegrationsWith = data + case "hasOrganization": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganization")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOrganization = data + case "hasOrganizationWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOrganizationWith = data + case "hasEvents": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEvents = data + case "hasEventsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) + data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEventsWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputHushOrder(ctx context.Context, obj interface{}) (generated.HushOrder, error) { - var it generated.HushOrder +func (ec *executionContext) unmarshalInputIntegrationHistoryOrder(ctx context.Context, obj interface{}) (generated.IntegrationHistoryOrder, error) { + var it generated.IntegrationHistoryOrder asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v @@ -288140,7 +294815,7 @@ func (ec *executionContext) unmarshalInputHushOrder(ctx context.Context, obj int it.Direction = data case "field": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) - data, err := ec.unmarshalNHushOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushOrderField(ctx, v) + data, err := ec.unmarshalNIntegrationHistoryOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationHistoryOrderField(ctx, v) if err != nil { return it, err } @@ -288151,14 +294826,14 @@ func (ec *executionContext) unmarshalInputHushOrder(ctx context.Context, obj int return it, nil } -func (ec *executionContext) unmarshalInputHushWhereInput(ctx context.Context, obj interface{}) (generated.HushWhereInput, error) { - var it generated.HushWhereInput +func (ec *executionContext) unmarshalInputIntegrationHistoryWhereInput(ctx context.Context, obj interface{}) (generated.IntegrationHistoryWhereInput, error) { + var it generated.IntegrationHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "kind", "kindNEQ", "kindIn", "kindNotIn", "kindGT", "kindGTE", "kindLT", "kindLTE", "kindContains", "kindHasPrefix", "kindHasSuffix", "kindIsNil", "kindNotNil", "kindEqualFold", "kindContainsFold", "secretName", "secretNameNEQ", "secretNameIn", "secretNameNotIn", "secretNameGT", "secretNameGTE", "secretNameLT", "secretNameLTE", "secretNameContains", "secretNameHasPrefix", "secretNameHasSuffix", "secretNameIsNil", "secretNameNotNil", "secretNameEqualFold", "secretNameContainsFold", "hasIntegrations", "hasIntegrationsWith", "hasOrganization", "hasOrganizationWith", "hasEvents", "hasEventsWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "kind", "kindNEQ", "kindIn", "kindNotIn", "kindGT", "kindGTE", "kindLT", "kindLTE", "kindContains", "kindHasPrefix", "kindHasSuffix", "kindIsNil", "kindNotNil", "kindEqualFold", "kindContainsFold"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -288167,21 +294842,21 @@ func (ec *executionContext) unmarshalInputHushWhereInput(ctx context.Context, ob switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOHushWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInput(ctx, v) + data, err := ec.unmarshalOIntegrationHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOHushWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOIntegrationHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOHushWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOIntegrationHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -288256,6 +294931,195 @@ func (ec *executionContext) unmarshalInputHushWhereInput(ctx context.Context, ob return it, err } it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOIntegrationHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOIntegrationHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOIntegrationHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOIntegrationHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -288781,6 +295645,111 @@ func (ec *executionContext) unmarshalInputHushWhereInput(ctx context.Context, ob return it, err } it.DeletedByContainsFold = data + case "ownerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerID = data + case "ownerIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDNEQ = data + case "ownerIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDIn = data + case "ownerIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDNotIn = data + case "ownerIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDGT = data + case "ownerIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDGTE = data + case "ownerIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDLT = data + case "ownerIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDLTE = data + case "ownerIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDContains = data + case "ownerIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDHasPrefix = data + case "ownerIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDHasSuffix = data + case "ownerIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDIsNil = data + case "ownerIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDNotNil = data + case "ownerIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDEqualFold = data + case "ownerIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDContainsFold = data case "name": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) @@ -288977,161 +295946,14 @@ func (ec *executionContext) unmarshalInputHushWhereInput(ctx context.Context, ob return it, err } it.KindContainsFold = data - case "secretName": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretName")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretName = data - case "secretNameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameNEQ = data - case "secretNameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.SecretNameIn = data - case "secretNameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.SecretNameNotIn = data - case "secretNameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameGT = data - case "secretNameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameGTE = data - case "secretNameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameLT = data - case "secretNameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameLTE = data - case "secretNameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameContains = data - case "secretNameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameHasPrefix = data - case "secretNameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameHasSuffix = data - case "secretNameIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.SecretNameIsNil = data - case "secretNameNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.SecretNameNotNil = data - case "secretNameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameEqualFold = data - case "secretNameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("secretNameContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.SecretNameContainsFold = data - case "hasIntegrations": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrations")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasIntegrations = data - case "hasIntegrationsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrationsWith")) - data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasIntegrationsWith = data - case "hasOrganization": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganization")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasOrganization = data - case "hasOrganizationWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasOrganizationWith = data - case "hasEvents": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasEvents = data - case "hasEventsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) - data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasEventsWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputIntegrationHistoryOrder(ctx context.Context, obj interface{}) (generated.IntegrationHistoryOrder, error) { - var it generated.IntegrationHistoryOrder +func (ec *executionContext) unmarshalInputIntegrationOrder(ctx context.Context, obj interface{}) (generated.IntegrationOrder, error) { + var it generated.IntegrationOrder asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v @@ -289157,7 +295979,7 @@ func (ec *executionContext) unmarshalInputIntegrationHistoryOrder(ctx context.Co it.Direction = data case "field": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) - data, err := ec.unmarshalNIntegrationHistoryOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationHistoryOrderField(ctx, v) + data, err := ec.unmarshalNIntegrationOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationOrderField(ctx, v) if err != nil { return it, err } @@ -289168,14 +295990,14 @@ func (ec *executionContext) unmarshalInputIntegrationHistoryOrder(ctx context.Co return it, nil } -func (ec *executionContext) unmarshalInputIntegrationHistoryWhereInput(ctx context.Context, obj interface{}) (generated.IntegrationHistoryWhereInput, error) { - var it generated.IntegrationHistoryWhereInput +func (ec *executionContext) unmarshalInputIntegrationWhereInput(ctx context.Context, obj interface{}) (generated.IntegrationWhereInput, error) { + var it generated.IntegrationWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "kind", "kindNEQ", "kindIn", "kindNotIn", "kindGT", "kindGTE", "kindLT", "kindLTE", "kindContains", "kindHasPrefix", "kindHasSuffix", "kindIsNil", "kindNotNil", "kindEqualFold", "kindContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "kind", "kindNEQ", "kindIn", "kindNotIn", "kindGT", "kindGTE", "kindLT", "kindLTE", "kindContains", "kindHasPrefix", "kindHasSuffix", "kindIsNil", "kindNotNil", "kindEqualFold", "kindContainsFold", "hasOwner", "hasOwnerWith", "hasSecrets", "hasSecretsWith", "hasOauth2tokens", "hasOauth2tokensWith", "hasEvents", "hasEventsWith", "hasWebhooks", "hasWebhooksWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -289184,21 +296006,21 @@ func (ec *executionContext) unmarshalInputIntegrationHistoryWhereInput(ctx conte switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOIntegrationHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationHistoryWhereInput(ctx, v) + data, err := ec.unmarshalOIntegrationWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOIntegrationHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOIntegrationHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -289273,195 +296095,6 @@ func (ec *executionContext) unmarshalInputIntegrationHistoryWhereInput(ctx conte return it, err } it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOIntegrationHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOIntegrationHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOIntegrationHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOIntegrationHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -289989,77 +296622,77 @@ func (ec *executionContext) unmarshalInputIntegrationHistoryWhereInput(ctx conte it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -290080,14 +296713,14 @@ func (ec *executionContext) unmarshalInputIntegrationHistoryWhereInput(ctx conte it.OwnerIDNotNil = data case "ownerIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDEqualFold = data case "ownerIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -290288,58 +296921,90 @@ func (ec *executionContext) unmarshalInputIntegrationHistoryWhereInput(ctx conte return it, err } it.KindContainsFold = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputIntegrationOrder(ctx context.Context, obj interface{}) (generated.IntegrationOrder, error) { - var it generated.IntegrationOrder - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - if _, present := asMap["direction"]; !present { - asMap["direction"] = "ASC" - } - - fieldsInOrder := [...]string{"direction", "field"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "direction": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("direction")) - data, err := ec.unmarshalNOrderDirection2entgoᚗioᚋcontribᚋentgqlᚐOrderDirection(ctx, v) + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.Direction = data - case "field": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field")) - data, err := ec.unmarshalNIntegrationOrderField2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationOrderField(ctx, v) + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.Field = data + it.HasOwnerWith = data + case "hasSecrets": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSecrets")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasSecrets = data + case "hasSecretsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSecretsWith")) + data, err := ec.unmarshalOHushWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasSecretsWith = data + case "hasOauth2tokens": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOauth2tokens")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOauth2tokens = data + case "hasOauth2tokensWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOauth2tokensWith")) + data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOauth2tokensWith = data + case "hasEvents": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEvents = data + case "hasEventsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) + data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEventsWith = data + case "hasWebhooks": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasWebhooks")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasWebhooks = data + case "hasWebhooksWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasWebhooksWith")) + data, err := ec.unmarshalOWebhookWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐWebhookWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasWebhooksWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputIntegrationWhereInput(ctx context.Context, obj interface{}) (generated.IntegrationWhereInput, error) { - var it generated.IntegrationWhereInput +func (ec *executionContext) unmarshalInputInternalPolicyHistoryWhereInput(ctx context.Context, obj interface{}) (generated.InternalPolicyHistoryWhereInput, error) { + var it generated.InternalPolicyHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "kind", "kindNEQ", "kindIn", "kindNotIn", "kindGT", "kindGTE", "kindLT", "kindLTE", "kindContains", "kindHasPrefix", "kindHasSuffix", "kindIsNil", "kindNotNil", "kindEqualFold", "kindContainsFold", "hasOwner", "hasOwnerWith", "hasSecrets", "hasSecretsWith", "hasOauth2tokens", "hasOauth2tokensWith", "hasEvents", "hasEventsWith", "hasWebhooks", "hasWebhooksWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "status", "statusNEQ", "statusIn", "statusNotIn", "statusGT", "statusGTE", "statusLT", "statusLTE", "statusContains", "statusHasPrefix", "statusHasSuffix", "statusIsNil", "statusNotNil", "statusEqualFold", "statusContainsFold", "policyType", "policyTypeNEQ", "policyTypeIn", "policyTypeNotIn", "policyTypeGT", "policyTypeGTE", "policyTypeLT", "policyTypeLTE", "policyTypeContains", "policyTypeHasPrefix", "policyTypeHasSuffix", "policyTypeIsNil", "policyTypeNotNil", "policyTypeEqualFold", "policyTypeContainsFold", "version", "versionNEQ", "versionIn", "versionNotIn", "versionGT", "versionGTE", "versionLT", "versionLTE", "versionContains", "versionHasPrefix", "versionHasSuffix", "versionIsNil", "versionNotNil", "versionEqualFold", "versionContainsFold", "purposeAndScope", "purposeAndScopeNEQ", "purposeAndScopeIn", "purposeAndScopeNotIn", "purposeAndScopeGT", "purposeAndScopeGTE", "purposeAndScopeLT", "purposeAndScopeLTE", "purposeAndScopeContains", "purposeAndScopeHasPrefix", "purposeAndScopeHasSuffix", "purposeAndScopeIsNil", "purposeAndScopeNotNil", "purposeAndScopeEqualFold", "purposeAndScopeContainsFold", "background", "backgroundNEQ", "backgroundIn", "backgroundNotIn", "backgroundGT", "backgroundGTE", "backgroundLT", "backgroundLTE", "backgroundContains", "backgroundHasPrefix", "backgroundHasSuffix", "backgroundIsNil", "backgroundNotNil", "backgroundEqualFold", "backgroundContainsFold"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -290348,21 +297013,21 @@ func (ec *executionContext) unmarshalInputIntegrationWhereInput(ctx context.Cont switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOIntegrationWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInput(ctx, v) + data, err := ec.unmarshalOInternalPolicyHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOInternalPolicyHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOInternalPolicyHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -290437,6 +297102,195 @@ func (ec *executionContext) unmarshalInputIntegrationWhereInput(ctx context.Cont return it, err } it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOInternalPolicyHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOInternalPolicyHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOInternalPolicyHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOInternalPolicyHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -290964,77 +297818,77 @@ func (ec *executionContext) unmarshalInputIntegrationWhereInput(ctx context.Cont it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } @@ -291055,14 +297909,14 @@ func (ec *executionContext) unmarshalInputIntegrationWhereInput(ctx context.Cont it.OwnerIDNotNil = data case "ownerIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDEqualFold = data case "ownerIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } @@ -291158,481 +298012,747 @@ func (ec *executionContext) unmarshalInputIntegrationWhereInput(ctx context.Cont return it, err } it.NameContainsFold = data - case "kind": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kind")) + case "description": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Kind = data - case "kindNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindNEQ")) + it.Description = data + case "descriptionNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindNEQ = data - case "kindIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindIn")) + it.DescriptionNEQ = data + case "descriptionIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.KindIn = data - case "kindNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindNotIn")) + it.DescriptionIn = data + case "descriptionNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.KindNotIn = data - case "kindGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindGT")) + it.DescriptionNotIn = data + case "descriptionGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindGT = data - case "kindGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindGTE")) + it.DescriptionGT = data + case "descriptionGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindGTE = data - case "kindLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindLT")) + it.DescriptionGTE = data + case "descriptionLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindLT = data - case "kindLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindLTE")) + it.DescriptionLT = data + case "descriptionLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindLTE = data - case "kindContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindContains")) + it.DescriptionLTE = data + case "descriptionContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindContains = data - case "kindHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindHasPrefix")) + it.DescriptionContains = data + case "descriptionHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindHasPrefix = data - case "kindHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindHasSuffix")) + it.DescriptionHasPrefix = data + case "descriptionHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindHasSuffix = data - case "kindIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindIsNil")) + it.DescriptionHasSuffix = data + case "descriptionIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.KindIsNil = data - case "kindNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindNotNil")) + it.DescriptionIsNil = data + case "descriptionNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.KindNotNil = data - case "kindEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindEqualFold")) + it.DescriptionNotNil = data + case "descriptionEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindEqualFold = data - case "kindContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("kindContainsFold")) + it.DescriptionEqualFold = data + case "descriptionContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.KindContainsFold = data - case "hasOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DescriptionContainsFold = data + case "status": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("status")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOwner = data - case "hasOwnerWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + it.Status = data + case "statusNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOwnerWith = data - case "hasSecrets": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSecrets")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.StatusNEQ = data + case "statusIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasSecrets = data - case "hasSecretsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSecretsWith")) - data, err := ec.unmarshalOHushWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐHushWhereInputᚄ(ctx, v) + it.StatusIn = data + case "statusNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasSecretsWith = data - case "hasOauth2tokens": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOauth2tokens")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.StatusNotIn = data + case "statusGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOauth2tokens = data - case "hasOauth2tokensWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOauth2tokensWith")) - data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInputᚄ(ctx, v) + it.StatusGT = data + case "statusGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOauth2tokensWith = data - case "hasEvents": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.StatusGTE = data + case "statusLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEvents = data - case "hasEventsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) - data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) + it.StatusLT = data + case "statusLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEventsWith = data - case "hasWebhooks": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasWebhooks")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.StatusLTE = data + case "statusContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasWebhooks = data - case "hasWebhooksWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasWebhooksWith")) - data, err := ec.unmarshalOWebhookWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐWebhookWhereInputᚄ(ctx, v) + it.StatusContains = data + case "statusHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasWebhooksWith = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputInternalPolicyHistoryWhereInput(ctx context.Context, obj interface{}) (generated.InternalPolicyHistoryWhereInput, error) { - var it generated.InternalPolicyHistoryWhereInput - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "status", "statusNEQ", "statusIn", "statusNotIn", "statusGT", "statusGTE", "statusLT", "statusLTE", "statusContains", "statusHasPrefix", "statusHasSuffix", "statusIsNil", "statusNotNil", "statusEqualFold", "statusContainsFold", "policyType", "policyTypeNEQ", "policyTypeIn", "policyTypeNotIn", "policyTypeGT", "policyTypeGTE", "policyTypeLT", "policyTypeLTE", "policyTypeContains", "policyTypeHasPrefix", "policyTypeHasSuffix", "policyTypeIsNil", "policyTypeNotNil", "policyTypeEqualFold", "policyTypeContainsFold", "version", "versionNEQ", "versionIn", "versionNotIn", "versionGT", "versionGTE", "versionLT", "versionLTE", "versionContains", "versionHasPrefix", "versionHasSuffix", "versionIsNil", "versionNotNil", "versionEqualFold", "versionContainsFold", "purposeAndScope", "purposeAndScopeNEQ", "purposeAndScopeIn", "purposeAndScopeNotIn", "purposeAndScopeGT", "purposeAndScopeGTE", "purposeAndScopeLT", "purposeAndScopeLTE", "purposeAndScopeContains", "purposeAndScopeHasPrefix", "purposeAndScopeHasSuffix", "purposeAndScopeIsNil", "purposeAndScopeNotNil", "purposeAndScopeEqualFold", "purposeAndScopeContainsFold", "background", "backgroundNEQ", "backgroundIn", "backgroundNotIn", "backgroundGT", "backgroundGTE", "backgroundLT", "backgroundLTE", "backgroundContains", "backgroundHasPrefix", "backgroundHasSuffix", "backgroundIsNil", "backgroundNotNil", "backgroundEqualFold", "backgroundContainsFold"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "not": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOInternalPolicyHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyHistoryWhereInput(ctx, v) + it.StatusHasPrefix = data + case "statusHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Not = data - case "and": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOInternalPolicyHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyHistoryWhereInputᚄ(ctx, v) + it.StatusHasSuffix = data + case "statusIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.And = data - case "or": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOInternalPolicyHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyHistoryWhereInputᚄ(ctx, v) + it.StatusIsNil = data + case "statusNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.Or = data - case "id": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.StatusNotNil = data + case "statusEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ID = data - case "idNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.StatusEqualFold = data + case "statusContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDNEQ = data - case "idIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.StatusContainsFold = data + case "policyType": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyType")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDIn = data - case "idNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.PolicyType = data + case "policyTypeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDNotIn = data - case "idGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.PolicyTypeNEQ = data + case "policyTypeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.IDGT = data - case "idGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.PolicyTypeIn = data + case "policyTypeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.IDGTE = data - case "idLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.PolicyTypeNotIn = data + case "policyTypeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDLT = data - case "idLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.PolicyTypeGT = data + case "policyTypeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDLTE = data - case "idEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.PolicyTypeGTE = data + case "policyTypeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDEqualFold = data - case "idContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.PolicyTypeLT = data + case "policyTypeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PolicyTypeLTE = data + case "policyTypeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PolicyTypeContains = data + case "policyTypeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.PolicyTypeHasPrefix = data + case "policyTypeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.PolicyTypeHasSuffix = data + case "policyTypeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PolicyTypeIsNil = data + case "policyTypeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PolicyTypeNotNil = data + case "policyTypeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PolicyTypeEqualFold = data + case "policyTypeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.PolicyTypeContainsFold = data + case "version": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("version")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + it.Version = data + case "versionNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + it.VersionNEQ = data + case "versionIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.VersionIn = data + case "versionNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.VersionNotIn = data + case "versionGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + it.VersionGT = data + case "versionGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.VersionGTE = data + case "versionLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.VersionLT = data + case "versionLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.VersionLTE = data + case "versionContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.VersionContains = data + case "versionHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.VersionHasPrefix = data + case "versionHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.VersionHasSuffix = data + case "versionIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.VersionIsNil = data + case "versionNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.VersionNotNil = data + case "versionEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.VersionEqualFold = data + case "versionContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.VersionContainsFold = data + case "purposeAndScope": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScope")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.PurposeAndScope = data + case "purposeAndScopeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.PurposeAndScopeNEQ = data + case "purposeAndScopeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + it.PurposeAndScopeIn = data + case "purposeAndScopeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + it.PurposeAndScopeNotIn = data + case "purposeAndScopeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + it.PurposeAndScopeGT = data + case "purposeAndScopeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + it.PurposeAndScopeGTE = data + case "purposeAndScopeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + it.PurposeAndScopeLT = data + case "purposeAndScopeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + it.PurposeAndScopeLTE = data + case "purposeAndScopeContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + it.PurposeAndScopeContains = data + case "purposeAndScopeHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + it.PurposeAndScopeHasPrefix = data + case "purposeAndScopeHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + it.PurposeAndScopeHasSuffix = data + case "purposeAndScopeIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + it.PurposeAndScopeIsNil = data + case "purposeAndScopeNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + it.PurposeAndScopeNotNil = data + case "purposeAndScopeEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + it.PurposeAndScopeEqualFold = data + case "purposeAndScopeContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOInternalPolicyHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + it.PurposeAndScopeContainsFold = data + case "background": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("background")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOInternalPolicyHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + it.Background = data + case "backgroundNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOInternalPolicyHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + it.BackgroundNEQ = data + case "backgroundIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOInternalPolicyHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + it.BackgroundIn = data + case "backgroundNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.OperationNotIn = data + it.BackgroundNotIn = data + case "backgroundGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.BackgroundGT = data + case "backgroundGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.BackgroundGTE = data + case "backgroundLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.BackgroundLT = data + case "backgroundLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.BackgroundLTE = data + case "backgroundContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.BackgroundContains = data + case "backgroundHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.BackgroundHasPrefix = data + case "backgroundHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.BackgroundHasSuffix = data + case "backgroundIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.BackgroundIsNil = data + case "backgroundNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.BackgroundNotNil = data + case "backgroundEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.BackgroundEqualFold = data + case "backgroundContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.BackgroundContainsFold = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputInternalPolicyWhereInput(ctx context.Context, obj interface{}) (generated.InternalPolicyWhereInput, error) { + var it generated.InternalPolicyWhereInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "status", "statusNEQ", "statusIn", "statusNotIn", "statusGT", "statusGTE", "statusLT", "statusLTE", "statusContains", "statusHasPrefix", "statusHasSuffix", "statusIsNil", "statusNotNil", "statusEqualFold", "statusContainsFold", "policyType", "policyTypeNEQ", "policyTypeIn", "policyTypeNotIn", "policyTypeGT", "policyTypeGTE", "policyTypeLT", "policyTypeLTE", "policyTypeContains", "policyTypeHasPrefix", "policyTypeHasSuffix", "policyTypeIsNil", "policyTypeNotNil", "policyTypeEqualFold", "policyTypeContainsFold", "version", "versionNEQ", "versionIn", "versionNotIn", "versionGT", "versionGTE", "versionLT", "versionLTE", "versionContains", "versionHasPrefix", "versionHasSuffix", "versionIsNil", "versionNotNil", "versionEqualFold", "versionContainsFold", "purposeAndScope", "purposeAndScopeNEQ", "purposeAndScopeIn", "purposeAndScopeNotIn", "purposeAndScopeGT", "purposeAndScopeGTE", "purposeAndScopeLT", "purposeAndScopeLTE", "purposeAndScopeContains", "purposeAndScopeHasPrefix", "purposeAndScopeHasSuffix", "purposeAndScopeIsNil", "purposeAndScopeNotNil", "purposeAndScopeEqualFold", "purposeAndScopeContainsFold", "background", "backgroundNEQ", "backgroundIn", "backgroundNotIn", "backgroundGT", "backgroundGTE", "backgroundLT", "backgroundLTE", "backgroundContains", "backgroundHasPrefix", "backgroundHasSuffix", "backgroundIsNil", "backgroundNotNil", "backgroundEqualFold", "backgroundContainsFold", "hasOwner", "hasOwnerWith", "hasBlockedGroups", "hasBlockedGroupsWith", "hasEditors", "hasEditorsWith", "hasControlobjectives", "hasControlobjectivesWith", "hasControls", "hasControlsWith", "hasProcedures", "hasProceduresWith", "hasNarratives", "hasNarrativesWith", "hasTasks", "hasTasksWith", "hasPrograms", "hasProgramsWith"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) + data, err := ec.unmarshalOInternalPolicyWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInput(ctx, v) + if err != nil { + return it, err + } + it.Not = data + case "and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) + data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.And = data + case "or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) + data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.Or = data + case "id": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ID = data + case "idNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDNEQ = data + case "idIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.IDIn = data + case "idNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.IDNotIn = data + case "idGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDGT = data + case "idGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDGTE = data + case "idLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDLT = data + case "idLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDLTE = data + case "idEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDEqualFold = data + case "idContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDContainsFold = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -292160,77 +299280,77 @@ func (ec *executionContext) unmarshalInputInternalPolicyHistoryWhereInput(ctx co it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -292251,14 +299371,14 @@ func (ec *executionContext) unmarshalInputInternalPolicyHistoryWhereInput(ctx co it.OwnerIDNotNil = data case "ownerIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDEqualFold = data case "ownerIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -292984,20 +300104,146 @@ func (ec *executionContext) unmarshalInputInternalPolicyHistoryWhereInput(ctx co return it, err } it.BackgroundContainsFold = data + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOwnerWith = data + case "hasBlockedGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasBlockedGroups")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasBlockedGroups = data + case "hasBlockedGroupsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasBlockedGroupsWith")) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasBlockedGroupsWith = data + case "hasEditors": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEditors")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEditors = data + case "hasEditorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEditorsWith")) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEditorsWith = data + case "hasControlobjectives": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectives")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjectives = data + case "hasControlobjectivesWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectivesWith")) + data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjectivesWith = data + case "hasControls": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControls")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControls = data + case "hasControlsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlsWith")) + data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlsWith = data + case "hasProcedures": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedures")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasProcedures = data + case "hasProceduresWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProceduresWith")) + data, err := ec.unmarshalOProcedureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProceduresWith = data + case "hasNarratives": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarratives")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasNarratives = data + case "hasNarrativesWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativesWith")) + data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasNarrativesWith = data + case "hasTasks": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTasks")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasTasks = data + case "hasTasksWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTasksWith")) + data, err := ec.unmarshalOTaskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasTasksWith = data + case "hasPrograms": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPrograms")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasPrograms = data + case "hasProgramsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramsWith")) + data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProgramsWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputInternalPolicyWhereInput(ctx context.Context, obj interface{}) (generated.InternalPolicyWhereInput, error) { - var it generated.InternalPolicyWhereInput +func (ec *executionContext) unmarshalInputInviteWhereInput(ctx context.Context, obj interface{}) (generated.InviteWhereInput, error) { + var it generated.InviteWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "status", "statusNEQ", "statusIn", "statusNotIn", "statusGT", "statusGTE", "statusLT", "statusLTE", "statusContains", "statusHasPrefix", "statusHasSuffix", "statusIsNil", "statusNotNil", "statusEqualFold", "statusContainsFold", "policyType", "policyTypeNEQ", "policyTypeIn", "policyTypeNotIn", "policyTypeGT", "policyTypeGTE", "policyTypeLT", "policyTypeLTE", "policyTypeContains", "policyTypeHasPrefix", "policyTypeHasSuffix", "policyTypeIsNil", "policyTypeNotNil", "policyTypeEqualFold", "policyTypeContainsFold", "version", "versionNEQ", "versionIn", "versionNotIn", "versionGT", "versionGTE", "versionLT", "versionLTE", "versionContains", "versionHasPrefix", "versionHasSuffix", "versionIsNil", "versionNotNil", "versionEqualFold", "versionContainsFold", "purposeAndScope", "purposeAndScopeNEQ", "purposeAndScopeIn", "purposeAndScopeNotIn", "purposeAndScopeGT", "purposeAndScopeGTE", "purposeAndScopeLT", "purposeAndScopeLTE", "purposeAndScopeContains", "purposeAndScopeHasPrefix", "purposeAndScopeHasSuffix", "purposeAndScopeIsNil", "purposeAndScopeNotNil", "purposeAndScopeEqualFold", "purposeAndScopeContainsFold", "background", "backgroundNEQ", "backgroundIn", "backgroundNotIn", "backgroundGT", "backgroundGTE", "backgroundLT", "backgroundLTE", "backgroundContains", "backgroundHasPrefix", "backgroundHasSuffix", "backgroundIsNil", "backgroundNotNil", "backgroundEqualFold", "backgroundContainsFold", "hasOwner", "hasOwnerWith", "hasBlockedGroups", "hasBlockedGroupsWith", "hasEditors", "hasEditorsWith", "hasControlobjectives", "hasControlobjectivesWith", "hasControls", "hasControlsWith", "hasProcedures", "hasProceduresWith", "hasNarratives", "hasNarrativesWith", "hasTasks", "hasTasksWith", "hasPrograms", "hasProgramsWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "expires", "expiresNEQ", "expiresIn", "expiresNotIn", "expiresGT", "expiresGTE", "expiresLT", "expiresLTE", "expiresIsNil", "expiresNotNil", "recipient", "recipientNEQ", "recipientIn", "recipientNotIn", "recipientGT", "recipientGTE", "recipientLT", "recipientLTE", "recipientContains", "recipientHasPrefix", "recipientHasSuffix", "recipientEqualFold", "recipientContainsFold", "status", "statusNEQ", "statusIn", "statusNotIn", "role", "roleNEQ", "roleIn", "roleNotIn", "sendAttempts", "sendAttemptsNEQ", "sendAttemptsIn", "sendAttemptsNotIn", "sendAttemptsGT", "sendAttemptsGTE", "sendAttemptsLT", "sendAttemptsLTE", "requestorID", "requestorIDNEQ", "requestorIDIn", "requestorIDNotIn", "requestorIDGT", "requestorIDGTE", "requestorIDLT", "requestorIDLTE", "requestorIDContains", "requestorIDHasPrefix", "requestorIDHasSuffix", "requestorIDIsNil", "requestorIDNotNil", "requestorIDEqualFold", "requestorIDContainsFold", "hasOwner", "hasOwnerWith", "hasEvents", "hasEventsWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -293006,21 +300252,21 @@ func (ec *executionContext) unmarshalInputInternalPolicyWhereInput(ctx context.C switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOInternalPolicyWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInput(ctx, v) + data, err := ec.unmarshalOInviteWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOInviteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOInviteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -293725,867 +300971,426 @@ func (ec *executionContext) unmarshalInputInternalPolicyWhereInput(ctx context.C return it, err } it.OwnerIDContainsFold = data - case "name": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Name = data - case "nameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameNEQ = data - case "nameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.NameIn = data - case "nameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + case "expires": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expires")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NameNotIn = data - case "nameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Expires = data + case "expiresNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NameGT = data - case "nameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ExpiresNEQ = data + case "expiresIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.NameGTE = data - case "nameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ExpiresIn = data + case "expiresNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.NameLT = data - case "nameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ExpiresNotIn = data + case "expiresGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NameLTE = data - case "nameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ExpiresGT = data + case "expiresGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NameContains = data - case "nameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ExpiresGTE = data + case "expiresLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NameHasPrefix = data - case "nameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ExpiresLT = data + case "expiresLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NameHasSuffix = data - case "nameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ExpiresLTE = data + case "expiresIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.NameEqualFold = data - case "nameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ExpiresIsNil = data + case "expiresNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.NameContainsFold = data - case "description": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description")) + it.ExpiresNotNil = data + case "recipient": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipient")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Description = data - case "descriptionNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNEQ")) + it.Recipient = data + case "recipientNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionNEQ = data - case "descriptionIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIn")) + it.RecipientNEQ = data + case "recipientIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DescriptionIn = data - case "descriptionNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotIn")) + it.RecipientIn = data + case "recipientNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.DescriptionNotIn = data - case "descriptionGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGT")) + it.RecipientNotIn = data + case "recipientGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionGT = data - case "descriptionGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGTE")) + it.RecipientGT = data + case "recipientGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionGTE = data - case "descriptionLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLT")) + it.RecipientGTE = data + case "recipientLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionLT = data - case "descriptionLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLTE")) + it.RecipientLT = data + case "recipientLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionLTE = data - case "descriptionContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContains")) + it.RecipientLTE = data + case "recipientContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionContains = data - case "descriptionHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasPrefix")) + it.RecipientContains = data + case "recipientHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionHasPrefix = data - case "descriptionHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasSuffix")) + it.RecipientHasPrefix = data + case "recipientHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionHasSuffix = data - case "descriptionIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.DescriptionIsNil = data - case "descriptionNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.DescriptionNotNil = data - case "descriptionEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionEqualFold")) + it.RecipientHasSuffix = data + case "recipientEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionEqualFold = data - case "descriptionContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContainsFold")) + it.RecipientEqualFold = data + case "recipientContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionContainsFold = data + it.RecipientContainsFold = data case "status": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("status")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOInviteInviteStatus2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐInviteStatus(ctx, v) if err != nil { return it, err } it.Status = data case "statusNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOInviteInviteStatus2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐInviteStatus(ctx, v) if err != nil { return it, err } it.StatusNEQ = data case "statusIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOInviteInviteStatus2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐInviteStatusᚄ(ctx, v) if err != nil { return it, err } it.StatusIn = data case "statusNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOInviteInviteStatus2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐInviteStatusᚄ(ctx, v) if err != nil { return it, err } it.StatusNotIn = data - case "statusGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StatusGT = data - case "statusGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StatusGTE = data - case "statusLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StatusLT = data - case "statusLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StatusLTE = data - case "statusContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StatusContains = data - case "statusHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StatusHasPrefix = data - case "statusHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StatusHasSuffix = data - case "statusIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StatusIsNil = data - case "statusNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.StatusNotNil = data - case "statusEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StatusEqualFold = data - case "statusContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.StatusContainsFold = data - case "policyType": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyType")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyType = data - case "policyTypeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeNEQ = data - case "policyTypeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeIn = data - case "policyTypeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeNotIn = data - case "policyTypeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeGT = data - case "policyTypeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeGTE = data - case "policyTypeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeLT = data - case "policyTypeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeLTE = data - case "policyTypeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeContains = data - case "policyTypeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeHasPrefix = data - case "policyTypeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeHasSuffix = data - case "policyTypeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeIsNil = data - case "policyTypeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeNotNil = data - case "policyTypeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeEqualFold = data - case "policyTypeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("policyTypeContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PolicyTypeContainsFold = data - case "version": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("version")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Version = data - case "versionNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionNEQ = data - case "versionIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.VersionIn = data - case "versionNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.VersionNotIn = data - case "versionGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionGT = data - case "versionGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionGTE = data - case "versionLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionLT = data - case "versionLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionLTE = data - case "versionContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionContains = data - case "versionHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionHasPrefix = data - case "versionHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionHasSuffix = data - case "versionIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.VersionIsNil = data - case "versionNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.VersionNotNil = data - case "versionEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionEqualFold = data - case "versionContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("versionContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.VersionContainsFold = data - case "purposeAndScope": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScope")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScope = data - case "purposeAndScopeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeNEQ = data - case "purposeAndScopeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeIn = data - case "purposeAndScopeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeNotIn = data - case "purposeAndScopeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeGT = data - case "purposeAndScopeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeGTE = data - case "purposeAndScopeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeLT = data - case "purposeAndScopeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeLTE = data - case "purposeAndScopeContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeContains = data - case "purposeAndScopeHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeHasPrefix = data - case "purposeAndScopeHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeHasSuffix = data - case "purposeAndScopeIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeIsNil = data - case "purposeAndScopeNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeNotNil = data - case "purposeAndScopeEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeEqualFold = data - case "purposeAndScopeContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("purposeAndScopeContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.PurposeAndScopeContainsFold = data - case "background": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("background")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Background = data - case "backgroundNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.BackgroundNEQ = data - case "backgroundIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + case "role": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) + data, err := ec.unmarshalOInviteRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } - it.BackgroundIn = data - case "backgroundNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.Role = data + case "roleNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNEQ")) + data, err := ec.unmarshalOInviteRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } - it.BackgroundNotIn = data - case "backgroundGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.RoleNEQ = data + case "roleIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleIn")) + data, err := ec.unmarshalOInviteRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } - it.BackgroundGT = data - case "backgroundGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.RoleIn = data + case "roleNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNotIn")) + data, err := ec.unmarshalOInviteRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } - it.BackgroundGTE = data - case "backgroundLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.RoleNotIn = data + case "sendAttempts": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttempts")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) if err != nil { return it, err } - it.BackgroundLT = data - case "backgroundLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.SendAttempts = data + case "sendAttemptsNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsNEQ")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) if err != nil { return it, err } - it.BackgroundLTE = data - case "backgroundContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.SendAttemptsNEQ = data + case "sendAttemptsIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsIn")) + data, err := ec.unmarshalOInt2ᚕintᚄ(ctx, v) if err != nil { return it, err } - it.BackgroundContains = data - case "backgroundHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.SendAttemptsIn = data + case "sendAttemptsNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsNotIn")) + data, err := ec.unmarshalOInt2ᚕintᚄ(ctx, v) if err != nil { return it, err } - it.BackgroundHasPrefix = data - case "backgroundHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.SendAttemptsNotIn = data + case "sendAttemptsGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsGT")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) if err != nil { return it, err } - it.BackgroundHasSuffix = data - case "backgroundIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.SendAttemptsGT = data + case "sendAttemptsGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsGTE")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) if err != nil { return it, err } - it.BackgroundIsNil = data - case "backgroundNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.SendAttemptsGTE = data + case "sendAttemptsLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsLT")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) if err != nil { return it, err } - it.BackgroundNotNil = data - case "backgroundEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.SendAttemptsLT = data + case "sendAttemptsLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsLTE")) + data, err := ec.unmarshalOInt2ᚖint(ctx, v) if err != nil { return it, err } - it.BackgroundEqualFold = data - case "backgroundContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("backgroundContainsFold")) + it.SendAttemptsLTE = data + case "requestorID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.BackgroundContainsFold = data - case "hasOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.RequestorID = data + case "requestorIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOwner = data - case "hasOwnerWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + it.RequestorIDNEQ = data + case "requestorIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasOwnerWith = data - case "hasBlockedGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasBlockedGroups")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.RequestorIDIn = data + case "requestorIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasBlockedGroups = data - case "hasBlockedGroupsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasBlockedGroupsWith")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + it.RequestorIDNotIn = data + case "requestorIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasBlockedGroupsWith = data - case "hasEditors": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEditors")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.RequestorIDGT = data + case "requestorIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEditors = data - case "hasEditorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEditorsWith")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + it.RequestorIDGTE = data + case "requestorIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasEditorsWith = data - case "hasControlobjectives": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectives")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.RequestorIDLT = data + case "requestorIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasControlobjectives = data - case "hasControlobjectivesWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectivesWith")) - data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) + it.RequestorIDLTE = data + case "requestorIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasControlobjectivesWith = data - case "hasControls": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControls")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.RequestorIDContains = data + case "requestorIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasControls = data - case "hasControlsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlsWith")) - data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) + it.RequestorIDHasPrefix = data + case "requestorIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasControlsWith = data - case "hasProcedures": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedures")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.RequestorIDHasSuffix = data + case "requestorIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasProcedures = data - case "hasProceduresWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProceduresWith")) - data, err := ec.unmarshalOProcedureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInputᚄ(ctx, v) + it.RequestorIDIsNil = data + case "requestorIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.HasProceduresWith = data - case "hasNarratives": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarratives")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.RequestorIDNotNil = data + case "requestorIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasNarratives = data - case "hasNarrativesWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasNarrativesWith")) - data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + it.RequestorIDEqualFold = data + case "requestorIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasNarrativesWith = data - case "hasTasks": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTasks")) + it.RequestorIDContainsFold = data + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.HasTasks = data - case "hasTasksWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasTasksWith")) - data, err := ec.unmarshalOTaskWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐTaskWhereInputᚄ(ctx, v) + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.HasTasksWith = data - case "hasPrograms": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPrograms")) + it.HasOwnerWith = data + case "hasEvents": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.HasPrograms = data - case "hasProgramsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramsWith")) - data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) + it.HasEvents = data + case "hasEventsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) + data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.HasProgramsWith = data + it.HasEventsWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputInviteWhereInput(ctx context.Context, obj interface{}) (generated.InviteWhereInput, error) { - var it generated.InviteWhereInput +func (ec *executionContext) unmarshalInputNarrativeHistoryWhereInput(ctx context.Context, obj interface{}) (generated.NarrativeHistoryWhereInput, error) { + var it generated.NarrativeHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "expires", "expiresNEQ", "expiresIn", "expiresNotIn", "expiresGT", "expiresGTE", "expiresLT", "expiresLTE", "expiresIsNil", "expiresNotNil", "recipient", "recipientNEQ", "recipientIn", "recipientNotIn", "recipientGT", "recipientGTE", "recipientLT", "recipientLTE", "recipientContains", "recipientHasPrefix", "recipientHasSuffix", "recipientEqualFold", "recipientContainsFold", "status", "statusNEQ", "statusIn", "statusNotIn", "role", "roleNEQ", "roleIn", "roleNotIn", "sendAttempts", "sendAttemptsNEQ", "sendAttemptsIn", "sendAttemptsNotIn", "sendAttemptsGT", "sendAttemptsGTE", "sendAttemptsLT", "sendAttemptsLTE", "requestorID", "requestorIDNEQ", "requestorIDIn", "requestorIDNotIn", "requestorIDGT", "requestorIDGTE", "requestorIDLT", "requestorIDLTE", "requestorIDContains", "requestorIDHasPrefix", "requestorIDHasSuffix", "requestorIDIsNil", "requestorIDNotNil", "requestorIDEqualFold", "requestorIDContainsFold", "hasOwner", "hasOwnerWith", "hasEvents", "hasEventsWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "satisfies", "satisfiesNEQ", "satisfiesIn", "satisfiesNotIn", "satisfiesGT", "satisfiesGTE", "satisfiesLT", "satisfiesLTE", "satisfiesContains", "satisfiesHasPrefix", "satisfiesHasSuffix", "satisfiesIsNil", "satisfiesNotNil", "satisfiesEqualFold", "satisfiesContainsFold"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -294594,21 +301399,21 @@ func (ec *executionContext) unmarshalInputInviteWhereInput(ctx context.Context, switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOInviteWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteWhereInput(ctx, v) + data, err := ec.unmarshalONarrativeHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOInviteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteWhereInputᚄ(ctx, v) + data, err := ec.unmarshalONarrativeHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOInviteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInviteWhereInputᚄ(ctx, v) + data, err := ec.unmarshalONarrativeHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -294683,6 +301488,195 @@ func (ec *executionContext) unmarshalInputInviteWhereInput(ctx context.Context, return it, err } it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalONarrativeHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalONarrativeHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalONarrativeHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalONarrativeHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -295210,529 +302204,410 @@ func (ec *executionContext) unmarshalInputInviteWhereInput(ctx context.Context, it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasSuffix = data - case "ownerIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDIsNil = data - case "ownerIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDNotNil = data case "ownerIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDEqualFold = data case "ownerIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContainsFold = data - case "expires": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expires")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.Expires = data - case "expiresNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.ExpiresNEQ = data - case "expiresIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.ExpiresIn = data - case "expiresNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.ExpiresNotIn = data - case "expiresGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.ExpiresGT = data - case "expiresGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.ExpiresGTE = data - case "expiresLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.ExpiresLT = data - case "expiresLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.ExpiresLTE = data - case "expiresIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.ExpiresIsNil = data - case "expiresNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.ExpiresNotNil = data - case "recipient": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipient")) + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Recipient = data - case "recipientNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientNEQ")) + it.Name = data + case "nameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientNEQ = data - case "recipientIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientIn")) + it.NameNEQ = data + case "nameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RecipientIn = data - case "recipientNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientNotIn")) + it.NameIn = data + case "nameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RecipientNotIn = data - case "recipientGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientGT")) + it.NameNotIn = data + case "nameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientGT = data - case "recipientGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientGTE")) + it.NameGT = data + case "nameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientGTE = data - case "recipientLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientLT")) + it.NameGTE = data + case "nameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientLT = data - case "recipientLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientLTE")) + it.NameLT = data + case "nameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientLTE = data - case "recipientContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientContains")) + it.NameLTE = data + case "nameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientContains = data - case "recipientHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientHasPrefix")) + it.NameContains = data + case "nameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientHasPrefix = data - case "recipientHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientHasSuffix")) + it.NameHasPrefix = data + case "nameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientHasSuffix = data - case "recipientEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientEqualFold")) + it.NameHasSuffix = data + case "nameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientEqualFold = data - case "recipientContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("recipientContainsFold")) + it.NameEqualFold = data + case "nameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RecipientContainsFold = data - case "status": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("status")) - data, err := ec.unmarshalOInviteInviteStatus2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐInviteStatus(ctx, v) - if err != nil { - return it, err - } - it.Status = data - case "statusNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNEQ")) - data, err := ec.unmarshalOInviteInviteStatus2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐInviteStatus(ctx, v) + it.NameContainsFold = data + case "description": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusNEQ = data - case "statusIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusIn")) - data, err := ec.unmarshalOInviteInviteStatus2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐInviteStatusᚄ(ctx, v) + it.Description = data + case "descriptionNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.StatusIn = data - case "statusNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("statusNotIn")) - data, err := ec.unmarshalOInviteInviteStatus2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐInviteStatusᚄ(ctx, v) + it.DescriptionNEQ = data + case "descriptionIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.StatusNotIn = data - case "role": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) - data, err := ec.unmarshalOInviteRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + it.DescriptionIn = data + case "descriptionNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.Role = data - case "roleNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNEQ")) - data, err := ec.unmarshalOInviteRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + it.DescriptionNotIn = data + case "descriptionGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RoleNEQ = data - case "roleIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleIn")) - data, err := ec.unmarshalOInviteRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + it.DescriptionGT = data + case "descriptionGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RoleIn = data - case "roleNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNotIn")) - data, err := ec.unmarshalOInviteRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + it.DescriptionGTE = data + case "descriptionLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RoleNotIn = data - case "sendAttempts": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttempts")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) + it.DescriptionLT = data + case "descriptionLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SendAttempts = data - case "sendAttemptsNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsNEQ")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) + it.DescriptionLTE = data + case "descriptionContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SendAttemptsNEQ = data - case "sendAttemptsIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsIn")) - data, err := ec.unmarshalOInt2ᚕintᚄ(ctx, v) + it.DescriptionContains = data + case "descriptionHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SendAttemptsIn = data - case "sendAttemptsNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsNotIn")) - data, err := ec.unmarshalOInt2ᚕintᚄ(ctx, v) + it.DescriptionHasPrefix = data + case "descriptionHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SendAttemptsNotIn = data - case "sendAttemptsGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsGT")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) + it.DescriptionHasSuffix = data + case "descriptionIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.SendAttemptsGT = data - case "sendAttemptsGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsGTE")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) + it.DescriptionIsNil = data + case "descriptionNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.SendAttemptsGTE = data - case "sendAttemptsLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsLT")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) + it.DescriptionNotNil = data + case "descriptionEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SendAttemptsLT = data - case "sendAttemptsLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sendAttemptsLTE")) - data, err := ec.unmarshalOInt2ᚖint(ctx, v) + it.DescriptionEqualFold = data + case "descriptionContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SendAttemptsLTE = data - case "requestorID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorID")) + it.DescriptionContainsFold = data + case "satisfies": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfies")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorID = data - case "requestorIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDNEQ")) + it.Satisfies = data + case "satisfiesNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDNEQ = data - case "requestorIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDIn")) + it.SatisfiesNEQ = data + case "satisfiesIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RequestorIDIn = data - case "requestorIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDNotIn")) + it.SatisfiesIn = data + case "satisfiesNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RequestorIDNotIn = data - case "requestorIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDGT")) + it.SatisfiesNotIn = data + case "satisfiesGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDGT = data - case "requestorIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDGTE")) + it.SatisfiesGT = data + case "satisfiesGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDGTE = data - case "requestorIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDLT")) + it.SatisfiesGTE = data + case "satisfiesLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDLT = data - case "requestorIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDLTE")) + it.SatisfiesLT = data + case "satisfiesLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDLTE = data - case "requestorIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDContains")) + it.SatisfiesLTE = data + case "satisfiesContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDContains = data - case "requestorIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDHasPrefix")) + it.SatisfiesContains = data + case "satisfiesHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDHasPrefix = data - case "requestorIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDHasSuffix")) + it.SatisfiesHasPrefix = data + case "satisfiesHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDHasSuffix = data - case "requestorIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDIsNil")) + it.SatisfiesHasSuffix = data + case "satisfiesIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.RequestorIDIsNil = data - case "requestorIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDNotNil")) + it.SatisfiesIsNil = data + case "satisfiesNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.RequestorIDNotNil = data - case "requestorIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDEqualFold")) + it.SatisfiesNotNil = data + case "satisfiesEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDEqualFold = data - case "requestorIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("requestorIDContainsFold")) + it.SatisfiesEqualFold = data + case "satisfiesContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RequestorIDContainsFold = data - case "hasOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasOwner = data - case "hasOwnerWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasOwnerWith = data - case "hasEvents": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasEvents = data - case "hasEventsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) - data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasEventsWith = data + it.SatisfiesContainsFold = data } } return it, nil } -func (ec *executionContext) unmarshalInputNarrativeHistoryWhereInput(ctx context.Context, obj interface{}) (generated.NarrativeHistoryWhereInput, error) { - var it generated.NarrativeHistoryWhereInput +func (ec *executionContext) unmarshalInputNarrativeWhereInput(ctx context.Context, obj interface{}) (generated.NarrativeWhereInput, error) { + var it generated.NarrativeWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "satisfies", "satisfiesNEQ", "satisfiesIn", "satisfiesNotIn", "satisfiesGT", "satisfiesGTE", "satisfiesLT", "satisfiesLTE", "satisfiesContains", "satisfiesHasPrefix", "satisfiesHasSuffix", "satisfiesIsNil", "satisfiesNotNil", "satisfiesEqualFold", "satisfiesContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "satisfies", "satisfiesNEQ", "satisfiesIn", "satisfiesNotIn", "satisfiesGT", "satisfiesGTE", "satisfiesLT", "satisfiesLTE", "satisfiesContains", "satisfiesHasPrefix", "satisfiesHasSuffix", "satisfiesIsNil", "satisfiesNotNil", "satisfiesEqualFold", "satisfiesContainsFold", "hasOwner", "hasOwnerWith", "hasBlockedGroups", "hasBlockedGroupsWith", "hasEditors", "hasEditorsWith", "hasViewers", "hasViewersWith", "hasPolicy", "hasPolicyWith", "hasControl", "hasControlWith", "hasProcedure", "hasProcedureWith", "hasControlobjective", "hasControlobjectiveWith", "hasPrograms", "hasProgramsWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -295741,21 +302616,21 @@ func (ec *executionContext) unmarshalInputNarrativeHistoryWhereInput(ctx context switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalONarrativeHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeHistoryWhereInput(ctx, v) + data, err := ec.unmarshalONarrativeWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalONarrativeHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalONarrativeHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -295830,195 +302705,6 @@ func (ec *executionContext) unmarshalInputNarrativeHistoryWhereInput(ctx context return it, err } it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalONarrativeHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalONarrativeHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalONarrativeHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalONarrativeHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -296546,91 +303232,91 @@ func (ec *executionContext) unmarshalInputNarrativeHistoryWhereInput(ctx context it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasSuffix = data case "ownerIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDEqualFold = data case "ownerIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -296936,20 +303622,146 @@ func (ec *executionContext) unmarshalInputNarrativeHistoryWhereInput(ctx context return it, err } it.SatisfiesContainsFold = data + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOwnerWith = data + case "hasBlockedGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasBlockedGroups")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasBlockedGroups = data + case "hasBlockedGroupsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasBlockedGroupsWith")) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasBlockedGroupsWith = data + case "hasEditors": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEditors")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEditors = data + case "hasEditorsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEditorsWith")) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEditorsWith = data + case "hasViewers": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasViewers")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasViewers = data + case "hasViewersWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasViewersWith")) + data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasViewersWith = data + case "hasPolicy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPolicy")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasPolicy = data + case "hasPolicyWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPolicyWith")) + data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasPolicyWith = data + case "hasControl": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControl")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControl = data + case "hasControlWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlWith")) + data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlWith = data + case "hasProcedure": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedure")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasProcedure = data + case "hasProcedureWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureWith")) + data, err := ec.unmarshalOProcedureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProcedureWith = data + case "hasControlobjective": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjective")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjective = data + case "hasControlobjectiveWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveWith")) + data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasControlobjectiveWith = data + case "hasPrograms": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPrograms")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasPrograms = data + case "hasProgramsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramsWith")) + data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProgramsWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputNarrativeWhereInput(ctx context.Context, obj interface{}) (generated.NarrativeWhereInput, error) { - var it generated.NarrativeWhereInput +func (ec *executionContext) unmarshalInputNoteHistoryWhereInput(ctx context.Context, obj interface{}) (generated.NoteHistoryWhereInput, error) { + var it generated.NoteHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "description", "descriptionNEQ", "descriptionIn", "descriptionNotIn", "descriptionGT", "descriptionGTE", "descriptionLT", "descriptionLTE", "descriptionContains", "descriptionHasPrefix", "descriptionHasSuffix", "descriptionIsNil", "descriptionNotNil", "descriptionEqualFold", "descriptionContainsFold", "satisfies", "satisfiesNEQ", "satisfiesIn", "satisfiesNotIn", "satisfiesGT", "satisfiesGTE", "satisfiesLT", "satisfiesLTE", "satisfiesContains", "satisfiesHasPrefix", "satisfiesHasSuffix", "satisfiesIsNil", "satisfiesNotNil", "satisfiesEqualFold", "satisfiesContainsFold", "hasOwner", "hasOwnerWith", "hasBlockedGroups", "hasBlockedGroupsWith", "hasEditors", "hasEditorsWith", "hasViewers", "hasViewersWith", "hasPolicy", "hasPolicyWith", "hasControl", "hasControlWith", "hasProcedure", "hasProcedureWith", "hasControlobjective", "hasControlobjectiveWith", "hasPrograms", "hasProgramsWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "text", "textNEQ", "textIn", "textNotIn", "textGT", "textGTE", "textLT", "textLTE", "textContains", "textHasPrefix", "textHasSuffix", "textEqualFold", "textContainsFold"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -296958,21 +303770,21 @@ func (ec *executionContext) unmarshalInputNarrativeWhereInput(ctx context.Contex switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalONarrativeWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInput(ctx, v) + data, err := ec.unmarshalONoteHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + data, err := ec.unmarshalONoteHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalONarrativeWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNarrativeWhereInputᚄ(ctx, v) + data, err := ec.unmarshalONoteHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -297047,6 +303859,195 @@ func (ec *executionContext) unmarshalInputNarrativeWhereInput(ctx context.Contex return it, err } it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalONoteHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalONoteHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalONoteHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalONoteHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -297574,536 +304575,214 @@ func (ec *executionContext) unmarshalInputNarrativeWhereInput(ctx context.Contex it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDHasSuffix = data - case "ownerIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDEqualFold = data - case "ownerIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDContainsFold = data - case "name": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Name = data - case "nameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameNEQ = data - case "nameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.NameIn = data - case "nameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.NameNotIn = data - case "nameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameGT = data - case "nameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameGTE = data - case "nameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameLT = data - case "nameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameLTE = data - case "nameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameContains = data - case "nameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameHasPrefix = data - case "nameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameHasSuffix = data - case "nameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameEqualFold = data - case "nameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameContainsFold = data - case "description": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("description")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Description = data - case "descriptionNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DescriptionNEQ = data - case "descriptionIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.DescriptionIn = data - case "descriptionNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.DescriptionNotIn = data - case "descriptionGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DescriptionGT = data - case "descriptionGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DescriptionGTE = data - case "descriptionLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DescriptionLT = data - case "descriptionLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DescriptionLTE = data - case "descriptionContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DescriptionContains = data - case "descriptionHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DescriptionHasPrefix = data - case "descriptionHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DescriptionHasSuffix = data - case "descriptionIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionIsNil")) + it.OwnerIDHasSuffix = data + case "ownerIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DescriptionIsNil = data - case "descriptionNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionNotNil")) + it.OwnerIDIsNil = data + case "ownerIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.DescriptionNotNil = data - case "descriptionEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionEqualFold")) + it.OwnerIDNotNil = data + case "ownerIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionEqualFold = data - case "descriptionContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("descriptionContainsFold")) + it.OwnerIDEqualFold = data + case "ownerIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.DescriptionContainsFold = data - case "satisfies": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfies")) + it.OwnerIDContainsFold = data + case "text": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Satisfies = data - case "satisfiesNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesNEQ")) + it.Text = data + case "textNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesNEQ = data - case "satisfiesIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesIn")) + it.TextNEQ = data + case "textIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.SatisfiesIn = data - case "satisfiesNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesNotIn")) + it.TextIn = data + case "textNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.SatisfiesNotIn = data - case "satisfiesGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesGT")) + it.TextNotIn = data + case "textGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesGT = data - case "satisfiesGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesGTE")) + it.TextGT = data + case "textGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesGTE = data - case "satisfiesLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesLT")) + it.TextGTE = data + case "textLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesLT = data - case "satisfiesLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesLTE")) + it.TextLT = data + case "textLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesLTE = data - case "satisfiesContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesContains")) + it.TextLTE = data + case "textContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesContains = data - case "satisfiesHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesHasPrefix")) + it.TextContains = data + case "textHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesHasPrefix = data - case "satisfiesHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesHasSuffix")) + it.TextHasPrefix = data + case "textHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesHasSuffix = data - case "satisfiesIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.SatisfiesIsNil = data - case "satisfiesNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.SatisfiesNotNil = data - case "satisfiesEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesEqualFold")) + it.TextHasSuffix = data + case "textEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesEqualFold = data - case "satisfiesContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("satisfiesContainsFold")) + it.TextEqualFold = data + case "textContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.SatisfiesContainsFold = data - case "hasOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasOwner = data - case "hasOwnerWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasOwnerWith = data - case "hasBlockedGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasBlockedGroups")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasBlockedGroups = data - case "hasBlockedGroupsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasBlockedGroupsWith")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasBlockedGroupsWith = data - case "hasEditors": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEditors")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasEditors = data - case "hasEditorsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEditorsWith")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasEditorsWith = data - case "hasViewers": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasViewers")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasViewers = data - case "hasViewersWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasViewersWith")) - data, err := ec.unmarshalOGroupWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐGroupWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasViewersWith = data - case "hasPolicy": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPolicy")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasPolicy = data - case "hasPolicyWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPolicyWith")) - data, err := ec.unmarshalOInternalPolicyWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐInternalPolicyWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasPolicyWith = data - case "hasControl": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControl")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControl = data - case "hasControlWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlWith")) - data, err := ec.unmarshalOControlWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlWith = data - case "hasProcedure": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedure")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasProcedure = data - case "hasProcedureWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProcedureWith")) - data, err := ec.unmarshalOProcedureWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProcedureWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasProcedureWith = data - case "hasControlobjective": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjective")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasControlobjective = data - case "hasControlobjectiveWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasControlobjectiveWith")) - data, err := ec.unmarshalOControlObjectiveWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐControlObjectiveWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasControlobjectiveWith = data - case "hasPrograms": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasPrograms")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasPrograms = data - case "hasProgramsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramsWith")) - data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasProgramsWith = data + it.TextContainsFold = data } } return it, nil } -func (ec *executionContext) unmarshalInputNoteHistoryWhereInput(ctx context.Context, obj interface{}) (generated.NoteHistoryWhereInput, error) { - var it generated.NoteHistoryWhereInput +func (ec *executionContext) unmarshalInputNoteWhereInput(ctx context.Context, obj interface{}) (generated.NoteWhereInput, error) { + var it generated.NoteWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "text", "textNEQ", "textIn", "textNotIn", "textGT", "textGTE", "textLT", "textLTE", "textContains", "textHasPrefix", "textHasSuffix", "textEqualFold", "textContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "text", "textNEQ", "textIn", "textNotIn", "textGT", "textGTE", "textLT", "textLTE", "textContains", "textHasPrefix", "textHasSuffix", "textEqualFold", "textContainsFold", "hasOwner", "hasOwnerWith", "hasEntity", "hasEntityWith", "hasSubcontrols", "hasSubcontrolsWith", "hasProgram", "hasProgramWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -298112,21 +304791,21 @@ func (ec *executionContext) unmarshalInputNoteHistoryWhereInput(ctx context.Cont switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalONoteHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteHistoryWhereInput(ctx, v) + data, err := ec.unmarshalONoteWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalONoteHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalONoteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalONoteHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalONoteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -298201,195 +304880,6 @@ func (ec *executionContext) unmarshalInputNoteHistoryWhereInput(ctx context.Cont return it, err } it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalONoteHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalONoteHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) - if err != nil { - return it, err - } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalONoteHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalONoteHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) - if err != nil { - return it, err - } - it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -298917,77 +305407,77 @@ func (ec *executionContext) unmarshalInputNoteHistoryWhereInput(ctx context.Cont it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -299008,14 +305498,14 @@ func (ec *executionContext) unmarshalInputNoteHistoryWhereInput(ctx context.Cont it.OwnerIDNotNil = data case "ownerIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDEqualFold = data case "ownerIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -299111,20 +305601,76 @@ func (ec *executionContext) unmarshalInputNoteHistoryWhereInput(ctx context.Cont return it, err } it.TextContainsFold = data + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOwnerWith = data + case "hasEntity": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntity")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasEntity = data + case "hasEntityWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntityWith")) + data, err := ec.unmarshalOEntityWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasEntityWith = data + case "hasSubcontrols": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSubcontrols")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasSubcontrols = data + case "hasSubcontrolsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSubcontrolsWith")) + data, err := ec.unmarshalOSubcontrolWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubcontrolWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasSubcontrolsWith = data + case "hasProgram": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgram")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasProgram = data + case "hasProgramWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramWith")) + data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasProgramWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputNoteWhereInput(ctx context.Context, obj interface{}) (generated.NoteWhereInput, error) { - var it generated.NoteWhereInput +func (ec *executionContext) unmarshalInputOauthProviderHistoryWhereInput(ctx context.Context, obj interface{}) (generated.OauthProviderHistoryWhereInput, error) { + var it generated.OauthProviderHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "text", "textNEQ", "textIn", "textNotIn", "textGT", "textGTE", "textLT", "textLTE", "textContains", "textHasPrefix", "textHasSuffix", "textEqualFold", "textContainsFold", "hasOwner", "hasOwnerWith", "hasEntity", "hasEntityWith", "hasSubcontrols", "hasSubcontrolsWith", "hasProgram", "hasProgramWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "clientID", "clientIDNEQ", "clientIDIn", "clientIDNotIn", "clientIDGT", "clientIDGTE", "clientIDLT", "clientIDLTE", "clientIDContains", "clientIDHasPrefix", "clientIDHasSuffix", "clientIDEqualFold", "clientIDContainsFold", "clientSecret", "clientSecretNEQ", "clientSecretIn", "clientSecretNotIn", "clientSecretGT", "clientSecretGTE", "clientSecretLT", "clientSecretLTE", "clientSecretContains", "clientSecretHasPrefix", "clientSecretHasSuffix", "clientSecretEqualFold", "clientSecretContainsFold", "redirectURL", "redirectURLNEQ", "redirectURLIn", "redirectURLNotIn", "redirectURLGT", "redirectURLGTE", "redirectURLLT", "redirectURLLTE", "redirectURLContains", "redirectURLHasPrefix", "redirectURLHasSuffix", "redirectURLEqualFold", "redirectURLContainsFold", "scopes", "scopesNEQ", "scopesIn", "scopesNotIn", "scopesGT", "scopesGTE", "scopesLT", "scopesLTE", "scopesContains", "scopesHasPrefix", "scopesHasSuffix", "scopesEqualFold", "scopesContainsFold", "authURL", "authURLNEQ", "authURLIn", "authURLNotIn", "authURLGT", "authURLGTE", "authURLLT", "authURLLTE", "authURLContains", "authURLHasPrefix", "authURLHasSuffix", "authURLEqualFold", "authURLContainsFold", "tokenURL", "tokenURLNEQ", "tokenURLIn", "tokenURLNotIn", "tokenURLGT", "tokenURLGTE", "tokenURLLT", "tokenURLLTE", "tokenURLContains", "tokenURLHasPrefix", "tokenURLHasSuffix", "tokenURLEqualFold", "tokenURLContainsFold", "authStyle", "authStyleNEQ", "authStyleIn", "authStyleNotIn", "authStyleGT", "authStyleGTE", "authStyleLT", "authStyleLTE", "infoURL", "infoURLNEQ", "infoURLIn", "infoURLNotIn", "infoURLGT", "infoURLGTE", "infoURLLT", "infoURLLTE", "infoURLContains", "infoURLHasPrefix", "infoURLHasSuffix", "infoURLEqualFold", "infoURLContainsFold"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -299133,21 +305679,21 @@ func (ec *executionContext) unmarshalInputNoteWhereInput(ctx context.Context, ob switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalONoteWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteWhereInput(ctx, v) + data, err := ec.unmarshalOOauthProviderHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalONoteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOauthProviderHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalONoteWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐNoteWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOauthProviderHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -299222,6 +305768,195 @@ func (ec *executionContext) unmarshalInputNoteWhereInput(ctx context.Context, ob return it, err } it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOOauthProviderHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOOauthProviderHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOOauthProviderHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOOauthProviderHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -299749,77 +306484,77 @@ func (ec *executionContext) unmarshalInputNoteWhereInput(ctx context.Context, ob it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } @@ -299840,465 +306575,913 @@ func (ec *executionContext) unmarshalInputNoteWhereInput(ctx context.Context, ob it.OwnerIDNotNil = data case "ownerIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDEqualFold = data case "ownerIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContainsFold = data - case "text": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("text")) + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Text = data - case "textNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textNEQ")) + it.Name = data + case "nameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextNEQ = data - case "textIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textIn")) + it.NameNEQ = data + case "nameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.TextIn = data - case "textNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textNotIn")) + it.NameIn = data + case "nameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.TextNotIn = data - case "textGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textGT")) + it.NameNotIn = data + case "nameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextGT = data - case "textGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textGTE")) + it.NameGT = data + case "nameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextGTE = data - case "textLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textLT")) + it.NameGTE = data + case "nameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextLT = data - case "textLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textLTE")) + it.NameLT = data + case "nameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextLTE = data - case "textContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textContains")) + it.NameLTE = data + case "nameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextContains = data - case "textHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textHasPrefix")) + it.NameContains = data + case "nameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextHasPrefix = data - case "textHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textHasSuffix")) + it.NameHasPrefix = data + case "nameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextHasSuffix = data - case "textEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textEqualFold")) + it.NameHasSuffix = data + case "nameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextEqualFold = data - case "textContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("textContainsFold")) + it.NameEqualFold = data + case "nameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TextContainsFold = data - case "hasOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.NameContainsFold = data + case "clientID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOwner = data - case "hasOwnerWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + it.ClientID = data + case "clientIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOwnerWith = data - case "hasEntity": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntity")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.ClientIDNEQ = data + case "clientIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasEntity = data - case "hasEntityWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEntityWith")) - data, err := ec.unmarshalOEntityWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEntityWhereInputᚄ(ctx, v) + it.ClientIDIn = data + case "clientIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HasEntityWith = data - case "hasSubcontrols": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSubcontrols")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.ClientIDNotIn = data + case "clientIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasSubcontrols = data - case "hasSubcontrolsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasSubcontrolsWith")) - data, err := ec.unmarshalOSubcontrolWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐSubcontrolWhereInputᚄ(ctx, v) + it.ClientIDGT = data + case "clientIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasSubcontrolsWith = data - case "hasProgram": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgram")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.ClientIDGTE = data + case "clientIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasProgram = data - case "hasProgramWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasProgramWith")) - data, err := ec.unmarshalOProgramWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐProgramWhereInputᚄ(ctx, v) + it.ClientIDLT = data + case "clientIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasProgramWith = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputOauthProviderHistoryWhereInput(ctx context.Context, obj interface{}) (generated.OauthProviderHistoryWhereInput, error) { - var it generated.OauthProviderHistoryWhereInput - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "clientID", "clientIDNEQ", "clientIDIn", "clientIDNotIn", "clientIDGT", "clientIDGTE", "clientIDLT", "clientIDLTE", "clientIDContains", "clientIDHasPrefix", "clientIDHasSuffix", "clientIDEqualFold", "clientIDContainsFold", "clientSecret", "clientSecretNEQ", "clientSecretIn", "clientSecretNotIn", "clientSecretGT", "clientSecretGTE", "clientSecretLT", "clientSecretLTE", "clientSecretContains", "clientSecretHasPrefix", "clientSecretHasSuffix", "clientSecretEqualFold", "clientSecretContainsFold", "redirectURL", "redirectURLNEQ", "redirectURLIn", "redirectURLNotIn", "redirectURLGT", "redirectURLGTE", "redirectURLLT", "redirectURLLTE", "redirectURLContains", "redirectURLHasPrefix", "redirectURLHasSuffix", "redirectURLEqualFold", "redirectURLContainsFold", "scopes", "scopesNEQ", "scopesIn", "scopesNotIn", "scopesGT", "scopesGTE", "scopesLT", "scopesLTE", "scopesContains", "scopesHasPrefix", "scopesHasSuffix", "scopesEqualFold", "scopesContainsFold", "authURL", "authURLNEQ", "authURLIn", "authURLNotIn", "authURLGT", "authURLGTE", "authURLLT", "authURLLTE", "authURLContains", "authURLHasPrefix", "authURLHasSuffix", "authURLEqualFold", "authURLContainsFold", "tokenURL", "tokenURLNEQ", "tokenURLIn", "tokenURLNotIn", "tokenURLGT", "tokenURLGTE", "tokenURLLT", "tokenURLLTE", "tokenURLContains", "tokenURLHasPrefix", "tokenURLHasSuffix", "tokenURLEqualFold", "tokenURLContainsFold", "authStyle", "authStyleNEQ", "authStyleIn", "authStyleNotIn", "authStyleGT", "authStyleGTE", "authStyleLT", "authStyleLTE", "infoURL", "infoURLNEQ", "infoURLIn", "infoURLNotIn", "infoURLGT", "infoURLGTE", "infoURLLT", "infoURLLTE", "infoURLContains", "infoURLHasPrefix", "infoURLHasSuffix", "infoURLEqualFold", "infoURLContainsFold"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "not": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOOauthProviderHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderHistoryWhereInput(ctx, v) + it.ClientIDLTE = data + case "clientIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Not = data - case "and": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOOauthProviderHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderHistoryWhereInputᚄ(ctx, v) + it.ClientIDContains = data + case "clientIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.And = data - case "or": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOOauthProviderHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderHistoryWhereInputᚄ(ctx, v) + it.ClientIDHasPrefix = data + case "clientIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Or = data - case "id": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.ClientIDHasSuffix = data + case "clientIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ID = data - case "idNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.ClientIDEqualFold = data + case "clientIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDNEQ = data - case "idIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.ClientIDContainsFold = data + case "clientSecret": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecret")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDIn = data - case "idNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.ClientSecret = data + case "clientSecretNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDNotIn = data - case "idGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.ClientSecretNEQ = data + case "clientSecretIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.IDGT = data - case "idGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.ClientSecretIn = data + case "clientSecretNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.IDGTE = data - case "idLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.ClientSecretNotIn = data + case "clientSecretGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDLT = data - case "idLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.ClientSecretGT = data + case "clientSecretGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDLTE = data - case "idEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.ClientSecretGTE = data + case "clientSecretLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDEqualFold = data - case "idContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) + it.ClientSecretLT = data + case "clientSecretLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.IDContainsFold = data - case "historyTime": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.ClientSecretLTE = data + case "clientSecretContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTime = data - case "historyTimeNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.ClientSecretContains = data + case "clientSecretHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeNEQ = data - case "historyTimeIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.ClientSecretHasPrefix = data + case "clientSecretHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeIn = data - case "historyTimeNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + it.ClientSecretHasSuffix = data + case "clientSecretEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeNotIn = data - case "historyTimeGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.ClientSecretEqualFold = data + case "clientSecretContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeGT = data - case "historyTimeGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.ClientSecretContainsFold = data + case "redirectURL": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURL")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeGTE = data - case "historyTimeLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.RedirectURL = data + case "redirectURLNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HistoryTimeLT = data - case "historyTimeLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + it.RedirectURLNEQ = data + case "redirectURLIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.HistoryTimeLTE = data - case "ref": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + it.RedirectURLIn = data + case "redirectURLNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RedirectURLNotIn = data + case "redirectURLGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Ref = data - case "refNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + it.RedirectURLGT = data + case "redirectURLGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefNEQ = data - case "refIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + it.RedirectURLGTE = data + case "redirectURLLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RedirectURLLT = data + case "redirectURLLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RedirectURLLTE = data + case "redirectURLContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RedirectURLContains = data + case "redirectURLHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RedirectURLHasPrefix = data + case "redirectURLHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RedirectURLHasSuffix = data + case "redirectURLEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RedirectURLEqualFold = data + case "redirectURLContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RedirectURLContainsFold = data + case "scopes": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopes")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Scopes = data + case "scopesNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesNEQ = data + case "scopesIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RefIn = data - case "refNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + it.ScopesIn = data + case "scopesNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ScopesNotIn = data + case "scopesGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesGT = data + case "scopesGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesGTE = data + case "scopesLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesLT = data + case "scopesLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesLTE = data + case "scopesContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesContains = data + case "scopesHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesHasPrefix = data + case "scopesHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesHasSuffix = data + case "scopesEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesEqualFold = data + case "scopesContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ScopesContainsFold = data + case "authURL": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURL")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURL = data + case "authURLNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLNEQ = data + case "authURLIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AuthURLIn = data + case "authURLNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AuthURLNotIn = data + case "authURLGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLGT = data + case "authURLGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLGTE = data + case "authURLLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLLT = data + case "authURLLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLLTE = data + case "authURLContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLContains = data + case "authURLHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLHasPrefix = data + case "authURLHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLHasSuffix = data + case "authURLEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLEqualFold = data + case "authURLContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURLContainsFold = data + case "tokenURL": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURL")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURL = data + case "tokenURLNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLNEQ = data + case "tokenURLIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.TokenURLIn = data + case "tokenURLNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.TokenURLNotIn = data + case "tokenURLGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLGT = data + case "tokenURLGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLGTE = data + case "tokenURLLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLLT = data + case "tokenURLLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLLTE = data + case "tokenURLContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLContains = data + case "tokenURLHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLHasPrefix = data + case "tokenURLHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLHasSuffix = data + case "tokenURLEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLEqualFold = data + case "tokenURLContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURLContainsFold = data + case "authStyle": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyle")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyle = data + case "authStyleNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleNEQ")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleNEQ = data + case "authStyleIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleIn")) + data, err := ec.unmarshalOUint2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8ᚄ(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleIn = data + case "authStyleNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleNotIn")) + data, err := ec.unmarshalOUint2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8ᚄ(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleNotIn = data + case "authStyleGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleGT")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleGT = data + case "authStyleGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleGTE")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleGTE = data + case "authStyleLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleLT")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleLT = data + case "authStyleLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleLTE")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleLTE = data + case "infoURL": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURL")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURL = data + case "infoURLNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLNEQ = data + case "infoURLIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RefNotIn = data - case "refGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + it.InfoURLIn = data + case "infoURLNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.InfoURLNotIn = data + case "infoURLGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLGT = data + case "infoURLGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLGTE = data + case "infoURLLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLLT = data + case "infoURLLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLLTE = data + case "infoURLContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLContains = data + case "infoURLHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLHasPrefix = data + case "infoURLHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLHasSuffix = data + case "infoURLEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefGT = data - case "refGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + it.InfoURLEqualFold = data + case "infoURLContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefGTE = data - case "refLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.InfoURLContainsFold = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputOauthProviderWhereInput(ctx context.Context, obj interface{}) (generated.OauthProviderWhereInput, error) { + var it generated.OauthProviderWhereInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "clientID", "clientIDNEQ", "clientIDIn", "clientIDNotIn", "clientIDGT", "clientIDGTE", "clientIDLT", "clientIDLTE", "clientIDContains", "clientIDHasPrefix", "clientIDHasSuffix", "clientIDEqualFold", "clientIDContainsFold", "clientSecret", "clientSecretNEQ", "clientSecretIn", "clientSecretNotIn", "clientSecretGT", "clientSecretGTE", "clientSecretLT", "clientSecretLTE", "clientSecretContains", "clientSecretHasPrefix", "clientSecretHasSuffix", "clientSecretEqualFold", "clientSecretContainsFold", "redirectURL", "redirectURLNEQ", "redirectURLIn", "redirectURLNotIn", "redirectURLGT", "redirectURLGTE", "redirectURLLT", "redirectURLLTE", "redirectURLContains", "redirectURLHasPrefix", "redirectURLHasSuffix", "redirectURLEqualFold", "redirectURLContainsFold", "scopes", "scopesNEQ", "scopesIn", "scopesNotIn", "scopesGT", "scopesGTE", "scopesLT", "scopesLTE", "scopesContains", "scopesHasPrefix", "scopesHasSuffix", "scopesEqualFold", "scopesContainsFold", "authURL", "authURLNEQ", "authURLIn", "authURLNotIn", "authURLGT", "authURLGTE", "authURLLT", "authURLLTE", "authURLContains", "authURLHasPrefix", "authURLHasSuffix", "authURLEqualFold", "authURLContainsFold", "tokenURL", "tokenURLNEQ", "tokenURLIn", "tokenURLNotIn", "tokenURLGT", "tokenURLGTE", "tokenURLLT", "tokenURLLTE", "tokenURLContains", "tokenURLHasPrefix", "tokenURLHasSuffix", "tokenURLEqualFold", "tokenURLContainsFold", "authStyle", "authStyleNEQ", "authStyleIn", "authStyleNotIn", "authStyleGT", "authStyleGTE", "authStyleLT", "authStyleLTE", "infoURL", "infoURLNEQ", "infoURLIn", "infoURLNotIn", "infoURLGT", "infoURLGTE", "infoURLLT", "infoURLLTE", "infoURLContains", "infoURLHasPrefix", "infoURLHasSuffix", "infoURLEqualFold", "infoURLContainsFold", "hasOwner", "hasOwnerWith"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) + data, err := ec.unmarshalOOauthProviderWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderWhereInput(ctx, v) if err != nil { return it, err } - it.RefLT = data - case "refLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Not = data + case "and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) + data, err := ec.unmarshalOOauthProviderWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.RefLTE = data - case "refContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.And = data + case "or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) + data, err := ec.unmarshalOOauthProviderWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.RefContains = data - case "refHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Or = data + case "id": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefHasPrefix = data - case "refHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ID = data + case "idNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefHasSuffix = data - case "refIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.IDNEQ = data + case "idIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RefIsNil = data - case "refNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) + it.IDIn = data + case "idNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RefNotNil = data - case "refEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDNotIn = data + case "idGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefEqualFold = data - case "refContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.IDGT = data + case "idGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RefContainsFold = data - case "operation": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOOauthProviderHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + it.IDGTE = data + case "idLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.Operation = data - case "operationNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOOauthProviderHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + it.IDLT = data + case "idLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.OperationNEQ = data - case "operationIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOOauthProviderHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + it.IDLTE = data + case "idEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.OperationIn = data - case "operationNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOOauthProviderHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + it.IDEqualFold = data + case "idContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.OperationNotIn = data + it.IDContainsFold = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -300826,77 +308009,77 @@ func (ec *executionContext) unmarshalInputOauthProviderHistoryWhereInput(ctx con it.DeletedByContainsFold = data case "ownerID": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerID = data case "ownerIDNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDNEQ = data case "ownerIDIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDIn = data case "ownerIDNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } it.OwnerIDNotIn = data case "ownerIDGT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGT = data case "ownerIDGTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDGTE = data case "ownerIDLT": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLT = data case "ownerIDLTE": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDLTE = data case "ownerIDContains": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDContains = data case "ownerIDHasPrefix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDHasPrefix = data case "ownerIDHasSuffix": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -300917,14 +308100,14 @@ func (ec *executionContext) unmarshalInputOauthProviderHistoryWhereInput(ctx con it.OwnerIDNotNil = data case "ownerIDEqualFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } it.OwnerIDEqualFold = data case "ownerIDContainsFold": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } @@ -301600,133 +308783,993 @@ func (ec *executionContext) unmarshalInputOauthProviderHistoryWhereInput(ctx con if err != nil { return it, err } - it.AuthStyleGT = data - case "authStyleGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleGTE")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + it.AuthStyleGT = data + case "authStyleGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleGTE")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleGTE = data + case "authStyleLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleLT")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleLT = data + case "authStyleLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleLTE")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyleLTE = data + case "infoURL": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURL")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURL = data + case "infoURLNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLNEQ = data + case "infoURLIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.InfoURLIn = data + case "infoURLNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.InfoURLNotIn = data + case "infoURLGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLGT = data + case "infoURLGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLGTE = data + case "infoURLLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLLT = data + case "infoURLLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLLTE = data + case "infoURLContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLContains = data + case "infoURLHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLHasPrefix = data + case "infoURLHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLHasSuffix = data + case "infoURLEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLEqualFold = data + case "infoURLContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURLContainsFold = data + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOwnerWith = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputOhAuthTooTokenWhereInput(ctx context.Context, obj interface{}) (generated.OhAuthTooTokenWhereInput, error) { + var it generated.OhAuthTooTokenWhereInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "clientID", "clientIDNEQ", "clientIDIn", "clientIDNotIn", "clientIDGT", "clientIDGTE", "clientIDLT", "clientIDLTE", "clientIDContains", "clientIDHasPrefix", "clientIDHasSuffix", "clientIDEqualFold", "clientIDContainsFold", "nonce", "nonceNEQ", "nonceIn", "nonceNotIn", "nonceGT", "nonceGTE", "nonceLT", "nonceLTE", "nonceContains", "nonceHasPrefix", "nonceHasSuffix", "nonceEqualFold", "nonceContainsFold", "claimsUserID", "claimsUserIDNEQ", "claimsUserIDIn", "claimsUserIDNotIn", "claimsUserIDGT", "claimsUserIDGTE", "claimsUserIDLT", "claimsUserIDLTE", "claimsUserIDContains", "claimsUserIDHasPrefix", "claimsUserIDHasSuffix", "claimsUserIDEqualFold", "claimsUserIDContainsFold", "claimsUsername", "claimsUsernameNEQ", "claimsUsernameIn", "claimsUsernameNotIn", "claimsUsernameGT", "claimsUsernameGTE", "claimsUsernameLT", "claimsUsernameLTE", "claimsUsernameContains", "claimsUsernameHasPrefix", "claimsUsernameHasSuffix", "claimsUsernameEqualFold", "claimsUsernameContainsFold", "claimsEmail", "claimsEmailNEQ", "claimsEmailIn", "claimsEmailNotIn", "claimsEmailGT", "claimsEmailGTE", "claimsEmailLT", "claimsEmailLTE", "claimsEmailContains", "claimsEmailHasPrefix", "claimsEmailHasSuffix", "claimsEmailEqualFold", "claimsEmailContainsFold", "claimsEmailVerified", "claimsEmailVerifiedNEQ", "claimsPreferredUsername", "claimsPreferredUsernameNEQ", "claimsPreferredUsernameIn", "claimsPreferredUsernameNotIn", "claimsPreferredUsernameGT", "claimsPreferredUsernameGTE", "claimsPreferredUsernameLT", "claimsPreferredUsernameLTE", "claimsPreferredUsernameContains", "claimsPreferredUsernameHasPrefix", "claimsPreferredUsernameHasSuffix", "claimsPreferredUsernameEqualFold", "claimsPreferredUsernameContainsFold", "connectorID", "connectorIDNEQ", "connectorIDIn", "connectorIDNotIn", "connectorIDGT", "connectorIDGTE", "connectorIDLT", "connectorIDLTE", "connectorIDContains", "connectorIDHasPrefix", "connectorIDHasSuffix", "connectorIDEqualFold", "connectorIDContainsFold", "lastUsed", "lastUsedNEQ", "lastUsedIn", "lastUsedNotIn", "lastUsedGT", "lastUsedGTE", "lastUsedLT", "lastUsedLTE", "hasIntegration", "hasIntegrationWith", "hasEvents", "hasEventsWith"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) + data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInput(ctx, v) + if err != nil { + return it, err + } + it.Not = data + case "and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) + data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.And = data + case "or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) + data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.Or = data + case "id": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ID = data + case "idNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDNEQ = data + case "idIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.IDIn = data + case "idNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.IDNotIn = data + case "idGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDGT = data + case "idGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDGTE = data + case "idLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDLT = data + case "idLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDLTE = data + case "idEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDEqualFold = data + case "idContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("idContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.IDContainsFold = data + case "clientID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientID = data + case "clientIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDNEQ = data + case "clientIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClientIDIn = data + case "clientIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClientIDNotIn = data + case "clientIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDGT = data + case "clientIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDGTE = data + case "clientIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDLT = data + case "clientIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDLTE = data + case "clientIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDContains = data + case "clientIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDHasPrefix = data + case "clientIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDHasSuffix = data + case "clientIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDEqualFold = data + case "clientIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientIDContainsFold = data + case "nonce": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonce")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Nonce = data + case "nonceNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceNEQ = data + case "nonceIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.NonceIn = data + case "nonceNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.NonceNotIn = data + case "nonceGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceGT = data + case "nonceGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceGTE = data + case "nonceLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceLT = data + case "nonceLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceLTE = data + case "nonceContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceContains = data + case "nonceHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceHasPrefix = data + case "nonceHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceHasSuffix = data + case "nonceEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceEqualFold = data + case "nonceContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.NonceContainsFold = data + case "claimsUserID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserID = data + case "claimsUserIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDNEQ = data + case "claimsUserIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDIn = data + case "claimsUserIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDNotIn = data + case "claimsUserIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDGT = data + case "claimsUserIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDGTE = data + case "claimsUserIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDLT = data + case "claimsUserIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDLTE = data + case "claimsUserIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDContains = data + case "claimsUserIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDHasPrefix = data + case "claimsUserIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDHasSuffix = data + case "claimsUserIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDEqualFold = data + case "claimsUserIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserIDContainsFold = data + case "claimsUsername": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsername")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsername = data + case "claimsUsernameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameNEQ = data + case "claimsUsernameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameIn = data + case "claimsUsernameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameNotIn = data + case "claimsUsernameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameGT = data + case "claimsUsernameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameGTE = data + case "claimsUsernameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameLT = data + case "claimsUsernameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameLTE = data + case "claimsUsernameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameContains = data + case "claimsUsernameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameHasPrefix = data + case "claimsUsernameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameHasSuffix = data + case "claimsUsernameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameEqualFold = data + case "claimsUsernameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsernameContainsFold = data + case "claimsEmail": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmail")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmail = data + case "claimsEmailNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailNEQ = data + case "claimsEmailIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailIn = data + case "claimsEmailNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailNotIn = data + case "claimsEmailGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailGT = data + case "claimsEmailGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailGTE = data + case "claimsEmailLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailLT = data + case "claimsEmailLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailLTE = data + case "claimsEmailContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailContains = data + case "claimsEmailHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailHasPrefix = data + case "claimsEmailHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailHasSuffix = data + case "claimsEmailEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailEqualFold = data + case "claimsEmailContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailContainsFold = data + case "claimsEmailVerified": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailVerified")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailVerified = data + case "claimsEmailVerifiedNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailVerifiedNEQ")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailVerifiedNEQ = data + case "claimsPreferredUsername": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsername")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsername = data + case "claimsPreferredUsernameNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameNEQ = data + case "claimsPreferredUsernameIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameIn = data + case "claimsPreferredUsernameNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameNotIn = data + case "claimsPreferredUsernameGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameGT = data + case "claimsPreferredUsernameGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameGTE = data + case "claimsPreferredUsernameLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameLT = data + case "claimsPreferredUsernameLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameLTE = data + case "claimsPreferredUsernameContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameContains = data + case "claimsPreferredUsernameHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameHasPrefix = data + case "claimsPreferredUsernameHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameHasSuffix = data + case "claimsPreferredUsernameEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameEqualFold = data + case "claimsPreferredUsernameContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsernameContainsFold = data + case "connectorID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ConnectorID = data + case "connectorIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ConnectorIDNEQ = data + case "connectorIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ConnectorIDIn = data + case "connectorIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ConnectorIDNotIn = data + case "connectorIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ConnectorIDGT = data + case "connectorIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ConnectorIDGTE = data + case "connectorIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ConnectorIDLT = data + case "connectorIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ConnectorIDLTE = data + case "connectorIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ConnectorIDContains = data + case "connectorIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleGTE = data - case "authStyleLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleLT")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + it.ConnectorIDHasPrefix = data + case "connectorIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleLT = data - case "authStyleLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleLTE")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + it.ConnectorIDHasSuffix = data + case "connectorIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleLTE = data - case "infoURL": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURL")) + it.ConnectorIDEqualFold = data + case "connectorIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURL = data - case "infoURLNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ConnectorIDContainsFold = data + case "lastUsed": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsed")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.InfoURLNEQ = data - case "infoURLIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.LastUsed = data + case "lastUsedNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.InfoURLIn = data - case "infoURLNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.LastUsedNEQ = data + case "lastUsedIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.InfoURLNotIn = data - case "infoURLGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.LastUsedIn = data + case "lastUsedNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.InfoURLGT = data - case "infoURLGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.LastUsedNotIn = data + case "lastUsedGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.InfoURLGTE = data - case "infoURLLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.LastUsedGT = data + case "lastUsedGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.InfoURLLT = data - case "infoURLLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.LastUsedGTE = data + case "lastUsedLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.InfoURLLTE = data - case "infoURLContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.LastUsedLT = data + case "lastUsedLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.InfoURLContains = data - case "infoURLHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.LastUsedLTE = data + case "hasIntegration": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegration")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.InfoURLHasPrefix = data - case "infoURLHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasIntegration = data + case "hasIntegrationWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrationWith")) + data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.InfoURLHasSuffix = data - case "infoURLEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasIntegrationWith = data + case "hasEvents": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.InfoURLEqualFold = data - case "infoURLContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.HasEvents = data + case "hasEventsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) + data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) if err != nil { return it, err } - it.InfoURLContainsFold = data + it.HasEventsWith = data } } return it, nil } -func (ec *executionContext) unmarshalInputOauthProviderWhereInput(ctx context.Context, obj interface{}) (generated.OauthProviderWhereInput, error) { - var it generated.OauthProviderWhereInput +func (ec *executionContext) unmarshalInputOrgMembershipHistoryWhereInput(ctx context.Context, obj interface{}) (generated.OrgMembershipHistoryWhereInput, error) { + var it generated.OrgMembershipHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "name", "nameNEQ", "nameIn", "nameNotIn", "nameGT", "nameGTE", "nameLT", "nameLTE", "nameContains", "nameHasPrefix", "nameHasSuffix", "nameEqualFold", "nameContainsFold", "clientID", "clientIDNEQ", "clientIDIn", "clientIDNotIn", "clientIDGT", "clientIDGTE", "clientIDLT", "clientIDLTE", "clientIDContains", "clientIDHasPrefix", "clientIDHasSuffix", "clientIDEqualFold", "clientIDContainsFold", "clientSecret", "clientSecretNEQ", "clientSecretIn", "clientSecretNotIn", "clientSecretGT", "clientSecretGTE", "clientSecretLT", "clientSecretLTE", "clientSecretContains", "clientSecretHasPrefix", "clientSecretHasSuffix", "clientSecretEqualFold", "clientSecretContainsFold", "redirectURL", "redirectURLNEQ", "redirectURLIn", "redirectURLNotIn", "redirectURLGT", "redirectURLGTE", "redirectURLLT", "redirectURLLTE", "redirectURLContains", "redirectURLHasPrefix", "redirectURLHasSuffix", "redirectURLEqualFold", "redirectURLContainsFold", "scopes", "scopesNEQ", "scopesIn", "scopesNotIn", "scopesGT", "scopesGTE", "scopesLT", "scopesLTE", "scopesContains", "scopesHasPrefix", "scopesHasSuffix", "scopesEqualFold", "scopesContainsFold", "authURL", "authURLNEQ", "authURLIn", "authURLNotIn", "authURLGT", "authURLGTE", "authURLLT", "authURLLTE", "authURLContains", "authURLHasPrefix", "authURLHasSuffix", "authURLEqualFold", "authURLContainsFold", "tokenURL", "tokenURLNEQ", "tokenURLIn", "tokenURLNotIn", "tokenURLGT", "tokenURLGTE", "tokenURLLT", "tokenURLLTE", "tokenURLContains", "tokenURLHasPrefix", "tokenURLHasSuffix", "tokenURLEqualFold", "tokenURLContainsFold", "authStyle", "authStyleNEQ", "authStyleIn", "authStyleNotIn", "authStyleGT", "authStyleGTE", "authStyleLT", "authStyleLTE", "infoURL", "infoURLNEQ", "infoURLIn", "infoURLNotIn", "infoURLGT", "infoURLGTE", "infoURLLT", "infoURLLTE", "infoURLContains", "infoURLHasPrefix", "infoURLHasSuffix", "infoURLEqualFold", "infoURLContainsFold", "hasOwner", "hasOwnerWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "role", "roleNEQ", "roleIn", "roleNotIn", "organizationID", "organizationIDNEQ", "organizationIDIn", "organizationIDNotIn", "organizationIDGT", "organizationIDGTE", "organizationIDLT", "organizationIDLTE", "organizationIDContains", "organizationIDHasPrefix", "organizationIDHasSuffix", "organizationIDEqualFold", "organizationIDContainsFold", "userID", "userIDNEQ", "userIDIn", "userIDNotIn", "userIDGT", "userIDGTE", "userIDLT", "userIDLTE", "userIDContains", "userIDHasPrefix", "userIDHasSuffix", "userIDEqualFold", "userIDContainsFold"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -301735,21 +309778,21 @@ func (ec *executionContext) unmarshalInputOauthProviderWhereInput(ctx context.Co switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOOauthProviderWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderWhereInput(ctx, v) + data, err := ec.unmarshalOOrgMembershipHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOOauthProviderWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOrgMembershipHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOOauthProviderWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOauthProviderWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOrgMembershipHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -301824,6 +309867,195 @@ func (ec *executionContext) unmarshalInputOauthProviderWhereInput(ctx context.Co return it, err } it.IDContainsFold = data + case "historyTime": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTime")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTime = data + case "historyTimeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNEQ = data + case "historyTimeIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeIn = data + case "historyTimeNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeNotIn = data + case "historyTimeGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGT = data + case "historyTimeGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeGTE = data + case "historyTimeLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLT = data + case "historyTimeLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("historyTimeLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.HistoryTimeLTE = data + case "ref": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ref")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Ref = data + case "refNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefNEQ = data + case "refIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefIn = data + case "refNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RefNotIn = data + case "refGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGT = data + case "refGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefGTE = data + case "refLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLT = data + case "refLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefLTE = data + case "refContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContains = data + case "refHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasPrefix = data + case "refHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefHasSuffix = data + case "refIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefIsNil = data + case "refNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.RefNotNil = data + case "refEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefEqualFold = data + case "refContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("refContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RefContainsFold = data + case "operation": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) + data, err := ec.unmarshalOOrgMembershipHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.Operation = data + case "operationNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) + data, err := ec.unmarshalOOrgMembershipHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + if err != nil { + return it, err + } + it.OperationNEQ = data + case "operationIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) + data, err := ec.unmarshalOOrgMembershipHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationIn = data + case "operationNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) + data, err := ec.unmarshalOOrgMembershipHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + if err != nil { + return it, err + } + it.OperationNotIn = data case "createdAt": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) @@ -302293,979 +310525,286 @@ func (ec *executionContext) unmarshalInputOauthProviderWhereInput(ctx context.Co return it, err } it.DeletedByLT = data - case "deletedByLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DeletedByLTE = data - case "deletedByContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DeletedByContains = data - case "deletedByHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DeletedByHasPrefix = data - case "deletedByHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DeletedByHasSuffix = data - case "deletedByIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.DeletedByIsNil = data - case "deletedByNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.DeletedByNotNil = data - case "deletedByEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DeletedByEqualFold = data - case "deletedByContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.DeletedByContainsFold = data - case "ownerID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerID = data - case "ownerIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDNEQ = data - case "ownerIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDIn = data - case "ownerIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDNotIn = data - case "ownerIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDGT = data - case "ownerIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDGTE = data - case "ownerIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDLT = data - case "ownerIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDLTE = data - case "ownerIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDContains = data - case "ownerIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDHasPrefix = data - case "ownerIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDHasSuffix = data - case "ownerIDIsNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDIsNil = data - case "ownerIDNotNil": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDNotNil = data - case "ownerIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDEqualFold = data - case "ownerIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerIDContainsFold = data - case "name": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Name = data - case "nameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameNEQ = data - case "nameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.NameIn = data - case "nameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.NameNotIn = data - case "nameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameGT = data - case "nameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameGTE = data - case "nameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameLT = data - case "nameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameLTE = data - case "nameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameContains = data - case "nameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameHasPrefix = data - case "nameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameHasSuffix = data - case "nameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameEqualFold = data - case "nameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nameContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.NameContainsFold = data - case "clientID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientID = data - case "clientIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDNEQ = data - case "clientIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ClientIDIn = data - case "clientIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ClientIDNotIn = data - case "clientIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDGT = data - case "clientIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDGTE = data - case "clientIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDLT = data - case "clientIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDLTE = data - case "clientIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDContains = data - case "clientIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDHasPrefix = data - case "clientIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDHasSuffix = data - case "clientIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDEqualFold = data - case "clientIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDContainsFold = data - case "clientSecret": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecret")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecret = data - case "clientSecretNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretNEQ = data - case "clientSecretIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretIn = data - case "clientSecretNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretNotIn = data - case "clientSecretGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretGT = data - case "clientSecretGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretGTE = data - case "clientSecretLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretLT = data - case "clientSecretLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretLTE = data - case "clientSecretContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretContains = data - case "clientSecretHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretHasPrefix = data - case "clientSecretHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretHasSuffix = data - case "clientSecretEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretEqualFold = data - case "clientSecretContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecretContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientSecretContainsFold = data - case "redirectURL": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURL")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURL = data - case "redirectURLNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLNEQ = data - case "redirectURLIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLIn = data - case "redirectURLNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLNotIn = data - case "redirectURLGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLGT = data - case "redirectURLGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLGTE = data - case "redirectURLLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLLT = data - case "redirectURLLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLLTE = data - case "redirectURLContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLContains = data - case "redirectURLHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLHasPrefix = data - case "redirectURLHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLHasSuffix = data - case "redirectURLEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLEqualFold = data - case "redirectURLContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURLContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURLContainsFold = data - case "scopes": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopes")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Scopes = data - case "scopesNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesNEQ = data - case "scopesIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ScopesIn = data - case "scopesNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ScopesNotIn = data - case "scopesGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesGT = data - case "scopesGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesGTE = data - case "scopesLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesLT = data - case "scopesLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesLTE = data - case "scopesContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesContains = data - case "scopesHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesHasPrefix = data - case "scopesHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesHasSuffix = data - case "scopesEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesEqualFold = data - case "scopesContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopesContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ScopesContainsFold = data - case "authURL": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURL")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURL = data - case "authURLNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURLNEQ = data - case "authURLIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.AuthURLIn = data - case "authURLNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.AuthURLNotIn = data - case "authURLGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURLGT = data - case "authURLGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURLGTE = data - case "authURLLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURLLT = data - case "authURLLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURLLTE = data - case "authURLContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURLContains = data - case "authURLHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURLHasPrefix = data - case "authURLHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURLHasSuffix = data - case "authURLEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLEqualFold")) + case "deletedByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthURLEqualFold = data - case "authURLContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURLContainsFold")) + it.DeletedByLTE = data + case "deletedByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthURLContainsFold = data - case "tokenURL": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURL")) + it.DeletedByContains = data + case "deletedByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TokenURL = data - case "tokenURLNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLNEQ")) + it.DeletedByHasPrefix = data + case "deletedByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TokenURLNEQ = data - case "tokenURLIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.DeletedByHasSuffix = data + case "deletedByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.TokenURLIn = data - case "tokenURLNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.DeletedByIsNil = data + case "deletedByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.TokenURLNotIn = data - case "tokenURLGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLGT")) + it.DeletedByNotNil = data + case "deletedByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TokenURLGT = data - case "tokenURLGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLGTE")) + it.DeletedByEqualFold = data + case "deletedByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TokenURLGTE = data - case "tokenURLLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedByContainsFold = data + case "role": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) + data, err := ec.unmarshalOOrgMembershipHistoryRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } - it.TokenURLLT = data - case "tokenURLLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Role = data + case "roleNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNEQ")) + data, err := ec.unmarshalOOrgMembershipHistoryRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } - it.TokenURLLTE = data - case "tokenURLContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.RoleNEQ = data + case "roleIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleIn")) + data, err := ec.unmarshalOOrgMembershipHistoryRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } - it.TokenURLContains = data - case "tokenURLHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.RoleIn = data + case "roleNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNotIn")) + data, err := ec.unmarshalOOrgMembershipHistoryRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } - it.TokenURLHasPrefix = data - case "tokenURLHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLHasSuffix")) + it.RoleNotIn = data + case "organizationID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TokenURLHasSuffix = data - case "tokenURLEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLEqualFold")) + it.OrganizationID = data + case "organizationIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.TokenURLEqualFold = data - case "tokenURLContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURLContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.OrganizationIDNEQ = data + case "organizationIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.TokenURLContainsFold = data - case "authStyle": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyle")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + it.OrganizationIDIn = data + case "organizationIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.AuthStyle = data - case "authStyleNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleNEQ")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + it.OrganizationIDNotIn = data + case "organizationIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleNEQ = data - case "authStyleIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleIn")) - data, err := ec.unmarshalOUint2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8ᚄ(ctx, v) + it.OrganizationIDGT = data + case "organizationIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleIn = data - case "authStyleNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleNotIn")) - data, err := ec.unmarshalOUint2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8ᚄ(ctx, v) + it.OrganizationIDGTE = data + case "organizationIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleNotIn = data - case "authStyleGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleGT")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + it.OrganizationIDLT = data + case "organizationIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleGT = data - case "authStyleGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleGTE")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + it.OrganizationIDLTE = data + case "organizationIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleGTE = data - case "authStyleLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleLT")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + it.OrganizationIDContains = data + case "organizationIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleLT = data - case "authStyleLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyleLTE")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + it.OrganizationIDHasPrefix = data + case "organizationIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.AuthStyleLTE = data - case "infoURL": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURL")) + it.OrganizationIDHasSuffix = data + case "organizationIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURL = data - case "infoURLNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLNEQ")) + it.OrganizationIDEqualFold = data + case "organizationIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLNEQ = data - case "infoURLIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.OrganizationIDContainsFold = data + case "userID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLIn = data - case "infoURLNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.UserID = data + case "userIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLNotIn = data - case "infoURLGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UserIDNEQ = data + case "userIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.InfoURLGT = data - case "infoURLGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UserIDIn = data + case "userIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.InfoURLGTE = data - case "infoURLLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLLT")) + it.UserIDNotIn = data + case "userIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLLT = data - case "infoURLLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLLTE")) + it.UserIDGT = data + case "userIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLLTE = data - case "infoURLContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLContains")) + it.UserIDGTE = data + case "userIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLContains = data - case "infoURLHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLHasPrefix")) + it.UserIDLT = data + case "userIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLHasPrefix = data - case "infoURLHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLHasSuffix")) + it.UserIDLTE = data + case "userIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLHasSuffix = data - case "infoURLEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLEqualFold")) + it.UserIDContains = data + case "userIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLEqualFold = data - case "infoURLContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURLContainsFold")) + it.UserIDHasPrefix = data + case "userIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.InfoURLContainsFold = data - case "hasOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.UserIDHasSuffix = data + case "userIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOwner = data - case "hasOwnerWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) - data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + it.UserIDEqualFold = data + case "userIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.HasOwnerWith = data + it.UserIDContainsFold = data } } return it, nil } -func (ec *executionContext) unmarshalInputOhAuthTooTokenWhereInput(ctx context.Context, obj interface{}) (generated.OhAuthTooTokenWhereInput, error) { - var it generated.OhAuthTooTokenWhereInput +func (ec *executionContext) unmarshalInputOrgMembershipWhereInput(ctx context.Context, obj interface{}) (generated.OrgMembershipWhereInput, error) { + var it generated.OrgMembershipWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "clientID", "clientIDNEQ", "clientIDIn", "clientIDNotIn", "clientIDGT", "clientIDGTE", "clientIDLT", "clientIDLTE", "clientIDContains", "clientIDHasPrefix", "clientIDHasSuffix", "clientIDEqualFold", "clientIDContainsFold", "nonce", "nonceNEQ", "nonceIn", "nonceNotIn", "nonceGT", "nonceGTE", "nonceLT", "nonceLTE", "nonceContains", "nonceHasPrefix", "nonceHasSuffix", "nonceEqualFold", "nonceContainsFold", "claimsUserID", "claimsUserIDNEQ", "claimsUserIDIn", "claimsUserIDNotIn", "claimsUserIDGT", "claimsUserIDGTE", "claimsUserIDLT", "claimsUserIDLTE", "claimsUserIDContains", "claimsUserIDHasPrefix", "claimsUserIDHasSuffix", "claimsUserIDEqualFold", "claimsUserIDContainsFold", "claimsUsername", "claimsUsernameNEQ", "claimsUsernameIn", "claimsUsernameNotIn", "claimsUsernameGT", "claimsUsernameGTE", "claimsUsernameLT", "claimsUsernameLTE", "claimsUsernameContains", "claimsUsernameHasPrefix", "claimsUsernameHasSuffix", "claimsUsernameEqualFold", "claimsUsernameContainsFold", "claimsEmail", "claimsEmailNEQ", "claimsEmailIn", "claimsEmailNotIn", "claimsEmailGT", "claimsEmailGTE", "claimsEmailLT", "claimsEmailLTE", "claimsEmailContains", "claimsEmailHasPrefix", "claimsEmailHasSuffix", "claimsEmailEqualFold", "claimsEmailContainsFold", "claimsEmailVerified", "claimsEmailVerifiedNEQ", "claimsPreferredUsername", "claimsPreferredUsernameNEQ", "claimsPreferredUsernameIn", "claimsPreferredUsernameNotIn", "claimsPreferredUsernameGT", "claimsPreferredUsernameGTE", "claimsPreferredUsernameLT", "claimsPreferredUsernameLTE", "claimsPreferredUsernameContains", "claimsPreferredUsernameHasPrefix", "claimsPreferredUsernameHasSuffix", "claimsPreferredUsernameEqualFold", "claimsPreferredUsernameContainsFold", "connectorID", "connectorIDNEQ", "connectorIDIn", "connectorIDNotIn", "connectorIDGT", "connectorIDGTE", "connectorIDLT", "connectorIDLTE", "connectorIDContains", "connectorIDHasPrefix", "connectorIDHasSuffix", "connectorIDEqualFold", "connectorIDContainsFold", "lastUsed", "lastUsedNEQ", "lastUsedIn", "lastUsedNotIn", "lastUsedGT", "lastUsedGTE", "lastUsedLT", "lastUsedLTE", "hasIntegration", "hasIntegrationWith", "hasEvents", "hasEventsWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "role", "roleNEQ", "roleIn", "roleNotIn", "organizationID", "userID"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -303274,21 +310813,21 @@ func (ec *executionContext) unmarshalInputOhAuthTooTokenWhereInput(ctx context.C switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInput(ctx, v) + data, err := ec.unmarshalOOrgMembershipWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOrgMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOOhAuthTooTokenWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOhAuthTooTokenWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOrgMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -303363,755 +310902,587 @@ func (ec *executionContext) unmarshalInputOhAuthTooTokenWhereInput(ctx context.C return it, err } it.IDContainsFold = data - case "clientID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientID = data - case "clientIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientIDNEQ = data - case "clientIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + case "createdAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClientIDIn = data - case "clientIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.CreatedAt = data + case "createdAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClientIDNotIn = data - case "clientIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtNEQ = data + case "createdAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.ClientIDGT = data - case "clientIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtIn = data + case "createdAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.ClientIDGTE = data - case "clientIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtNotIn = data + case "createdAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClientIDLT = data - case "clientIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtGT = data + case "createdAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClientIDLTE = data - case "clientIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtGTE = data + case "createdAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClientIDContains = data - case "clientIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtLT = data + case "createdAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClientIDHasPrefix = data - case "clientIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtLTE = data + case "createdAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClientIDHasSuffix = data - case "clientIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtIsNil = data + case "createdAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClientIDEqualFold = data - case "clientIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientIDContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedAtNotNil = data + case "updatedAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClientIDContainsFold = data - case "nonce": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonce")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAt = data + case "updatedAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.Nonce = data - case "nonceNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceNEQ")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtNEQ = data + case "updatedAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.NonceNEQ = data - case "nonceIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.UpdatedAtIn = data + case "updatedAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.NonceIn = data - case "nonceNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.UpdatedAtNotIn = data + case "updatedAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NonceNotIn = data - case "nonceGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtGT = data + case "updatedAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NonceGT = data - case "nonceGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtGTE = data + case "updatedAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NonceGTE = data - case "nonceLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtLT = data + case "updatedAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.NonceLT = data - case "nonceLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtLTE = data + case "updatedAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.NonceLTE = data - case "nonceContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedAtIsNil = data + case "updatedAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.NonceContains = data - case "nonceHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceHasPrefix")) + it.UpdatedAtNotNil = data + case "createdBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdBy")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NonceHasPrefix = data - case "nonceHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceHasSuffix")) + it.CreatedBy = data + case "createdByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.NonceHasSuffix = data - case "nonceEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedByNEQ = data + case "createdByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.NonceEqualFold = data - case "nonceContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonceContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedByIn = data + case "createdByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.NonceContainsFold = data - case "claimsUserID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserID")) + it.CreatedByNotIn = data + case "createdByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUserID = data - case "claimsUserIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDNEQ")) + it.CreatedByGT = data + case "createdByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDNEQ = data - case "claimsUserIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ClaimsUserIDIn = data - case "claimsUserIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ClaimsUserIDNotIn = data - case "claimsUserIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDGT")) + it.CreatedByGTE = data + case "createdByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDGT = data - case "claimsUserIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDGTE")) + it.CreatedByLT = data + case "createdByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDGTE = data - case "claimsUserIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDLT")) + it.CreatedByLTE = data + case "createdByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDLT = data - case "claimsUserIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDLTE")) + it.CreatedByContains = data + case "createdByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDLTE = data - case "claimsUserIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDContains")) + it.CreatedByHasPrefix = data + case "createdByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDContains = data - case "claimsUserIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedByHasSuffix = data + case "createdByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDHasPrefix = data - case "claimsUserIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.CreatedByIsNil = data + case "createdByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDHasSuffix = data - case "claimsUserIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDEqualFold")) + it.CreatedByNotNil = data + case "createdByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDEqualFold = data - case "claimsUserIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserIDContainsFold")) + it.CreatedByEqualFold = data + case "createdByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("createdByContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUserIDContainsFold = data - case "claimsUsername": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsername")) + it.CreatedByContainsFold = data + case "updatedBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedBy")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUsername = data - case "claimsUsernameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameNEQ")) + it.UpdatedBy = data + case "updatedByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameNEQ = data - case "claimsUsernameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameIn")) + it.UpdatedByNEQ = data + case "updatedByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameIn = data - case "claimsUsernameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameNotIn")) + it.UpdatedByIn = data + case "updatedByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameNotIn = data - case "claimsUsernameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClaimsUsernameGT = data - case "claimsUsernameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameGTE")) + it.UpdatedByNotIn = data + case "updatedByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameGTE = data - case "claimsUsernameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameLT")) + it.UpdatedByGT = data + case "updatedByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameLT = data - case "claimsUsernameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameLTE")) + it.UpdatedByGTE = data + case "updatedByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameLTE = data - case "claimsUsernameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameContains")) + it.UpdatedByLT = data + case "updatedByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameContains = data - case "claimsUsernameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameHasPrefix")) + it.UpdatedByLTE = data + case "updatedByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameHasPrefix = data - case "claimsUsernameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameHasSuffix")) + it.UpdatedByContains = data + case "updatedByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameHasSuffix = data - case "claimsUsernameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameEqualFold")) + it.UpdatedByHasPrefix = data + case "updatedByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameEqualFold = data - case "claimsUsernameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsernameContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedByHasSuffix = data + case "updatedByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClaimsUsernameContainsFold = data - case "claimsEmail": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmail")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedByIsNil = data + case "updatedByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClaimsEmail = data - case "claimsEmailNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailNEQ")) + it.UpdatedByNotNil = data + case "updatedByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsEmailNEQ = data - case "claimsEmailIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ClaimsEmailIn = data - case "claimsEmailNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ClaimsEmailNotIn = data - case "claimsEmailGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailGT")) + it.UpdatedByEqualFold = data + case "updatedByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("updatedByContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsEmailGT = data - case "claimsEmailGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.UpdatedByContainsFold = data + case "deletedAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClaimsEmailGTE = data - case "claimsEmailLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAt = data + case "deletedAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClaimsEmailLT = data - case "claimsEmailLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtNEQ = data + case "deletedAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.ClaimsEmailLTE = data - case "claimsEmailContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtIn = data + case "deletedAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) if err != nil { return it, err } - it.ClaimsEmailContains = data - case "claimsEmailHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtNotIn = data + case "deletedAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClaimsEmailHasPrefix = data - case "claimsEmailHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtGT = data + case "deletedAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClaimsEmailHasSuffix = data - case "claimsEmailEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailEqualFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtGTE = data + case "deletedAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClaimsEmailEqualFold = data - case "claimsEmailContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailContainsFold")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedAtLT = data + case "deletedAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.ClaimsEmailContainsFold = data - case "claimsEmailVerified": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailVerified")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DeletedAtLTE = data + case "deletedAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClaimsEmailVerified = data - case "claimsEmailVerifiedNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailVerifiedNEQ")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + it.DeletedAtIsNil = data + case "deletedAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClaimsEmailVerifiedNEQ = data - case "claimsPreferredUsername": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsername")) + it.DeletedAtNotNil = data + case "deletedBy": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedBy")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsername = data - case "claimsPreferredUsernameNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameNEQ")) + it.DeletedBy = data + case "deletedByNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsernameNEQ = data - case "claimsPreferredUsernameIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameIn")) + it.DeletedByNEQ = data + case "deletedByIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsernameIn = data - case "claimsPreferredUsernameNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameNotIn")) + it.DeletedByIn = data + case "deletedByNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsernameNotIn = data - case "claimsPreferredUsernameGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClaimsPreferredUsernameGT = data - case "claimsPreferredUsernameGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameGTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClaimsPreferredUsernameGTE = data - case "claimsPreferredUsernameLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameLT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClaimsPreferredUsernameLT = data - case "claimsPreferredUsernameLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClaimsPreferredUsernameLTE = data - case "claimsPreferredUsernameContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameContains")) + it.DeletedByNotIn = data + case "deletedByGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsernameContains = data - case "claimsPreferredUsernameHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameHasPrefix")) + it.DeletedByGT = data + case "deletedByGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsernameHasPrefix = data - case "claimsPreferredUsernameHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameHasSuffix")) + it.DeletedByGTE = data + case "deletedByLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsernameHasSuffix = data - case "claimsPreferredUsernameEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameEqualFold")) + it.DeletedByLT = data + case "deletedByLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsernameEqualFold = data - case "claimsPreferredUsernameContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsernameContainsFold")) + it.DeletedByLTE = data + case "deletedByContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsernameContainsFold = data - case "connectorID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorID")) + it.DeletedByContains = data + case "deletedByHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ConnectorID = data - case "connectorIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDNEQ")) + it.DeletedByHasPrefix = data + case "deletedByHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ConnectorIDNEQ = data - case "connectorIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ConnectorIDIn = data - case "connectorIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDNotIn")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + it.DeletedByHasSuffix = data + case "deletedByIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ConnectorIDNotIn = data - case "connectorIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDGT")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedByIsNil = data + case "deletedByNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ConnectorIDGT = data - case "connectorIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDGTE")) + it.DeletedByNotNil = data + case "deletedByEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ConnectorIDGTE = data - case "connectorIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDLT")) + it.DeletedByEqualFold = data + case "deletedByContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("deletedByContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ConnectorIDLT = data - case "connectorIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDLTE")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.DeletedByContainsFold = data + case "role": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) + data, err := ec.unmarshalOOrgMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } - it.ConnectorIDLTE = data - case "connectorIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDContains")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.Role = data + case "roleNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNEQ")) + data, err := ec.unmarshalOOrgMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) if err != nil { return it, err } - it.ConnectorIDContains = data - case "connectorIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDHasPrefix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.RoleNEQ = data + case "roleIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleIn")) + data, err := ec.unmarshalOOrgMembershipRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } - it.ConnectorIDHasPrefix = data - case "connectorIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDHasSuffix")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.RoleIn = data + case "roleNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNotIn")) + data, err := ec.unmarshalOOrgMembershipRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) if err != nil { return it, err } - it.ConnectorIDHasSuffix = data - case "connectorIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDEqualFold")) + it.RoleNotIn = data + case "organizationID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ConnectorIDEqualFold = data - case "connectorIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorIDContainsFold")) + it.OrganizationID = data + case "userID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ConnectorIDContainsFold = data - case "lastUsed": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsed")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.LastUsed = data - case "lastUsedNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedNEQ")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.LastUsedNEQ = data - case "lastUsedIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.LastUsedIn = data - case "lastUsedNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedNotIn")) - data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) - if err != nil { - return it, err - } - it.LastUsedNotIn = data - case "lastUsedGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedGT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.LastUsedGT = data - case "lastUsedGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedGTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.LastUsedGTE = data - case "lastUsedLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedLT")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.LastUsedLT = data - case "lastUsedLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsedLTE")) - data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) - if err != nil { - return it, err - } - it.LastUsedLTE = data - case "hasIntegration": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegration")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasIntegration = data - case "hasIntegrationWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasIntegrationWith")) - data, err := ec.unmarshalOIntegrationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐIntegrationWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasIntegrationWith = data - case "hasEvents": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEvents")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.HasEvents = data - case "hasEventsWith": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasEventsWith")) - data, err := ec.unmarshalOEventWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐEventWhereInputᚄ(ctx, v) - if err != nil { - return it, err - } - it.HasEventsWith = data + it.UserID = data } } return it, nil } -func (ec *executionContext) unmarshalInputOrgMembershipHistoryWhereInput(ctx context.Context, obj interface{}) (generated.OrgMembershipHistoryWhereInput, error) { - var it generated.OrgMembershipHistoryWhereInput +func (ec *executionContext) unmarshalInputOrgSubscriptionHistoryWhereInput(ctx context.Context, obj interface{}) (generated.OrgSubscriptionHistoryWhereInput, error) { + var it generated.OrgSubscriptionHistoryWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "role", "roleNEQ", "roleIn", "roleNotIn", "organizationID", "organizationIDNEQ", "organizationIDIn", "organizationIDNotIn", "organizationIDGT", "organizationIDGTE", "organizationIDLT", "organizationIDLTE", "organizationIDContains", "organizationIDHasPrefix", "organizationIDHasSuffix", "organizationIDEqualFold", "organizationIDContainsFold", "userID", "userIDNEQ", "userIDIn", "userIDNotIn", "userIDGT", "userIDGTE", "userIDLT", "userIDLTE", "userIDContains", "userIDHasPrefix", "userIDHasSuffix", "userIDEqualFold", "userIDContainsFold"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "historyTime", "historyTimeNEQ", "historyTimeIn", "historyTimeNotIn", "historyTimeGT", "historyTimeGTE", "historyTimeLT", "historyTimeLTE", "ref", "refNEQ", "refIn", "refNotIn", "refGT", "refGTE", "refLT", "refLTE", "refContains", "refHasPrefix", "refHasSuffix", "refIsNil", "refNotNil", "refEqualFold", "refContainsFold", "operation", "operationNEQ", "operationIn", "operationNotIn", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "stripeSubscriptionID", "stripeSubscriptionIDNEQ", "stripeSubscriptionIDIn", "stripeSubscriptionIDNotIn", "stripeSubscriptionIDGT", "stripeSubscriptionIDGTE", "stripeSubscriptionIDLT", "stripeSubscriptionIDLTE", "stripeSubscriptionIDContains", "stripeSubscriptionIDHasPrefix", "stripeSubscriptionIDHasSuffix", "stripeSubscriptionIDIsNil", "stripeSubscriptionIDNotNil", "stripeSubscriptionIDEqualFold", "stripeSubscriptionIDContainsFold", "productTier", "productTierNEQ", "productTierIn", "productTierNotIn", "productTierGT", "productTierGTE", "productTierLT", "productTierLTE", "productTierContains", "productTierHasPrefix", "productTierHasSuffix", "productTierIsNil", "productTierNotNil", "productTierEqualFold", "productTierContainsFold", "stripeProductTierID", "stripeProductTierIDNEQ", "stripeProductTierIDIn", "stripeProductTierIDNotIn", "stripeProductTierIDGT", "stripeProductTierIDGTE", "stripeProductTierIDLT", "stripeProductTierIDLTE", "stripeProductTierIDContains", "stripeProductTierIDHasPrefix", "stripeProductTierIDHasSuffix", "stripeProductTierIDIsNil", "stripeProductTierIDNotNil", "stripeProductTierIDEqualFold", "stripeProductTierIDContainsFold", "stripeSubscriptionStatus", "stripeSubscriptionStatusNEQ", "stripeSubscriptionStatusIn", "stripeSubscriptionStatusNotIn", "stripeSubscriptionStatusGT", "stripeSubscriptionStatusGTE", "stripeSubscriptionStatusLT", "stripeSubscriptionStatusLTE", "stripeSubscriptionStatusContains", "stripeSubscriptionStatusHasPrefix", "stripeSubscriptionStatusHasSuffix", "stripeSubscriptionStatusIsNil", "stripeSubscriptionStatusNotNil", "stripeSubscriptionStatusEqualFold", "stripeSubscriptionStatusContainsFold", "active", "activeNEQ", "stripeCustomerID", "stripeCustomerIDNEQ", "stripeCustomerIDIn", "stripeCustomerIDNotIn", "stripeCustomerIDGT", "stripeCustomerIDGTE", "stripeCustomerIDLT", "stripeCustomerIDLTE", "stripeCustomerIDContains", "stripeCustomerIDHasPrefix", "stripeCustomerIDHasSuffix", "stripeCustomerIDIsNil", "stripeCustomerIDNotNil", "stripeCustomerIDEqualFold", "stripeCustomerIDContainsFold", "expiresAt", "expiresAtNEQ", "expiresAtIn", "expiresAtNotIn", "expiresAtGT", "expiresAtGTE", "expiresAtLT", "expiresAtLTE", "expiresAtIsNil", "expiresAtNotNil"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -304120,21 +311491,21 @@ func (ec *executionContext) unmarshalInputOrgMembershipHistoryWhereInput(ctx con switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOOrgMembershipHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipHistoryWhereInput(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOOrgMembershipHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOOrgMembershipHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipHistoryWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -304372,28 +311743,28 @@ func (ec *executionContext) unmarshalInputOrgMembershipHistoryWhereInput(ctx con it.RefContainsFold = data case "operation": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operation")) - data, err := ec.unmarshalOOrgMembershipHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } it.Operation = data case "operationNEQ": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNEQ")) - data, err := ec.unmarshalOOrgMembershipHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, v) if err != nil { return it, err } it.OperationNEQ = data case "operationIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationIn")) - data, err := ec.unmarshalOOrgMembershipHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } it.OperationIn = data case "operationNotIn": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("operationNotIn")) - data, err := ec.unmarshalOOrgMembershipHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx, v) if err != nil { return it, err } @@ -304923,230 +312294,734 @@ func (ec *executionContext) unmarshalInputOrgMembershipHistoryWhereInput(ctx con return it, err } it.DeletedByContainsFold = data - case "role": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) - data, err := ec.unmarshalOOrgMembershipHistoryRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + case "ownerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Role = data - case "roleNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNEQ")) - data, err := ec.unmarshalOOrgMembershipHistoryRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + it.OwnerID = data + case "ownerIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.RoleNEQ = data - case "roleIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleIn")) - data, err := ec.unmarshalOOrgMembershipHistoryRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + it.OwnerIDNEQ = data + case "ownerIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RoleIn = data - case "roleNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNotIn")) - data, err := ec.unmarshalOOrgMembershipHistoryRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + it.OwnerIDIn = data + case "ownerIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RoleNotIn = data - case "organizationID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationID")) + it.OwnerIDNotIn = data + case "ownerIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationID = data - case "organizationIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDNEQ")) + it.OwnerIDGT = data + case "ownerIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDNEQ = data - case "organizationIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDIn")) + it.OwnerIDGTE = data + case "ownerIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDLT = data + case "ownerIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDLTE = data + case "ownerIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDContains = data + case "ownerIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDHasPrefix = data + case "ownerIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDHasSuffix = data + case "ownerIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDIsNil = data + case "ownerIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDNotNil = data + case "ownerIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDEqualFold = data + case "ownerIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDContainsFold = data + case "stripeSubscriptionID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionID = data + case "stripeSubscriptionIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDNEQ = data + case "stripeSubscriptionIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.OrganizationIDIn = data - case "organizationIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDNotIn")) + it.StripeSubscriptionIDIn = data + case "stripeSubscriptionIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.OrganizationIDNotIn = data - case "organizationIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDGT")) + it.StripeSubscriptionIDNotIn = data + case "stripeSubscriptionIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDGT = data - case "organizationIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDGTE")) + it.StripeSubscriptionIDGT = data + case "stripeSubscriptionIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDGTE = data - case "organizationIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDLT")) + it.StripeSubscriptionIDGTE = data + case "stripeSubscriptionIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDLT = data - case "organizationIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDLTE")) + it.StripeSubscriptionIDLT = data + case "stripeSubscriptionIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDLTE = data - case "organizationIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDContains")) + it.StripeSubscriptionIDLTE = data + case "stripeSubscriptionIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDContains = data - case "organizationIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDHasPrefix")) + it.StripeSubscriptionIDContains = data + case "stripeSubscriptionIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDHasPrefix = data - case "organizationIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDHasSuffix")) + it.StripeSubscriptionIDHasPrefix = data + case "stripeSubscriptionIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDHasSuffix = data - case "organizationIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDEqualFold")) + it.StripeSubscriptionIDHasSuffix = data + case "stripeSubscriptionIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDIsNil = data + case "stripeSubscriptionIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDNotNil = data + case "stripeSubscriptionIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDEqualFold = data - case "organizationIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationIDContainsFold")) + it.StripeSubscriptionIDEqualFold = data + case "stripeSubscriptionIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationIDContainsFold = data - case "userID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userID")) + it.StripeSubscriptionIDContainsFold = data + case "productTier": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTier")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserID = data - case "userIDNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDNEQ")) + it.ProductTier = data + case "productTierNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDNEQ = data - case "userIDIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDIn")) + it.ProductTierNEQ = data + case "productTierIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.UserIDIn = data - case "userIDNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDNotIn")) + it.ProductTierIn = data + case "productTierNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierNotIn")) data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.UserIDNotIn = data - case "userIDGT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDGT")) + it.ProductTierNotIn = data + case "productTierGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierGT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDGT = data - case "userIDGTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDGTE")) + it.ProductTierGT = data + case "productTierGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierGTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDGTE = data - case "userIDLT": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDLT")) + it.ProductTierGTE = data + case "productTierLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierLT")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDLT = data - case "userIDLTE": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDLTE")) + it.ProductTierLT = data + case "productTierLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierLTE")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDLTE = data - case "userIDContains": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDContains")) + it.ProductTierLTE = data + case "productTierContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierContains")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDContains = data - case "userIDHasPrefix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDHasPrefix")) + it.ProductTierContains = data + case "productTierHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierHasPrefix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDHasPrefix = data - case "userIDHasSuffix": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDHasSuffix")) + it.ProductTierHasPrefix = data + case "productTierHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierHasSuffix")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDHasSuffix = data - case "userIDEqualFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDEqualFold")) + it.ProductTierHasSuffix = data + case "productTierIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ProductTierIsNil = data + case "productTierNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ProductTierNotNil = data + case "productTierEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierEqualFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDEqualFold = data - case "userIDContainsFold": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userIDContainsFold")) + it.ProductTierEqualFold = data + case "productTierContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierContainsFold")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserIDContainsFold = data + it.ProductTierContainsFold = data + case "stripeProductTierID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierID = data + case "stripeProductTierIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDNEQ = data + case "stripeProductTierIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDIn = data + case "stripeProductTierIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDNotIn = data + case "stripeProductTierIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDGT = data + case "stripeProductTierIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDGTE = data + case "stripeProductTierIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDLT = data + case "stripeProductTierIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDLTE = data + case "stripeProductTierIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDContains = data + case "stripeProductTierIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDHasPrefix = data + case "stripeProductTierIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDHasSuffix = data + case "stripeProductTierIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDIsNil = data + case "stripeProductTierIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDNotNil = data + case "stripeProductTierIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDEqualFold = data + case "stripeProductTierIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDContainsFold = data + case "stripeSubscriptionStatus": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatus")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatus = data + case "stripeSubscriptionStatusNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusNEQ = data + case "stripeSubscriptionStatusIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusIn = data + case "stripeSubscriptionStatusNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusNotIn = data + case "stripeSubscriptionStatusGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusGT = data + case "stripeSubscriptionStatusGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusGTE = data + case "stripeSubscriptionStatusLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusLT = data + case "stripeSubscriptionStatusLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusLTE = data + case "stripeSubscriptionStatusContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusContains = data + case "stripeSubscriptionStatusHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusHasPrefix = data + case "stripeSubscriptionStatusHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusHasSuffix = data + case "stripeSubscriptionStatusIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusIsNil = data + case "stripeSubscriptionStatusNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusNotNil = data + case "stripeSubscriptionStatusEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusEqualFold = data + case "stripeSubscriptionStatusContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusContainsFold = data + case "active": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("active")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.Active = data + case "activeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("activeNEQ")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.ActiveNEQ = data + case "stripeCustomerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerID = data + case "stripeCustomerIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDNEQ = data + case "stripeCustomerIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDIn = data + case "stripeCustomerIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDNotIn = data + case "stripeCustomerIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDGT = data + case "stripeCustomerIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDGTE = data + case "stripeCustomerIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDLT = data + case "stripeCustomerIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDLTE = data + case "stripeCustomerIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDContains = data + case "stripeCustomerIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDHasPrefix = data + case "stripeCustomerIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDHasSuffix = data + case "stripeCustomerIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDIsNil = data + case "stripeCustomerIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDNotNil = data + case "stripeCustomerIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDEqualFold = data + case "stripeCustomerIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDContainsFold = data + case "expiresAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAt = data + case "expiresAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtNEQ = data + case "expiresAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtIn = data + case "expiresAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtNotIn = data + case "expiresAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtGT = data + case "expiresAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtGTE = data + case "expiresAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtLT = data + case "expiresAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtLTE = data + case "expiresAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtIsNil = data + case "expiresAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtNotNil = data } } return it, nil } -func (ec *executionContext) unmarshalInputOrgMembershipWhereInput(ctx context.Context, obj interface{}) (generated.OrgMembershipWhereInput, error) { - var it generated.OrgMembershipWhereInput +func (ec *executionContext) unmarshalInputOrgSubscriptionWhereInput(ctx context.Context, obj interface{}) (generated.OrgSubscriptionWhereInput, error) { + var it generated.OrgSubscriptionWhereInput asMap := map[string]interface{}{} for k, v := range obj.(map[string]interface{}) { asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "role", "roleNEQ", "roleIn", "roleNotIn", "organizationID", "userID"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "ownerID", "ownerIDNEQ", "ownerIDIn", "ownerIDNotIn", "ownerIDGT", "ownerIDGTE", "ownerIDLT", "ownerIDLTE", "ownerIDContains", "ownerIDHasPrefix", "ownerIDHasSuffix", "ownerIDIsNil", "ownerIDNotNil", "ownerIDEqualFold", "ownerIDContainsFold", "stripeSubscriptionID", "stripeSubscriptionIDNEQ", "stripeSubscriptionIDIn", "stripeSubscriptionIDNotIn", "stripeSubscriptionIDGT", "stripeSubscriptionIDGTE", "stripeSubscriptionIDLT", "stripeSubscriptionIDLTE", "stripeSubscriptionIDContains", "stripeSubscriptionIDHasPrefix", "stripeSubscriptionIDHasSuffix", "stripeSubscriptionIDIsNil", "stripeSubscriptionIDNotNil", "stripeSubscriptionIDEqualFold", "stripeSubscriptionIDContainsFold", "productTier", "productTierNEQ", "productTierIn", "productTierNotIn", "productTierGT", "productTierGTE", "productTierLT", "productTierLTE", "productTierContains", "productTierHasPrefix", "productTierHasSuffix", "productTierIsNil", "productTierNotNil", "productTierEqualFold", "productTierContainsFold", "stripeProductTierID", "stripeProductTierIDNEQ", "stripeProductTierIDIn", "stripeProductTierIDNotIn", "stripeProductTierIDGT", "stripeProductTierIDGTE", "stripeProductTierIDLT", "stripeProductTierIDLTE", "stripeProductTierIDContains", "stripeProductTierIDHasPrefix", "stripeProductTierIDHasSuffix", "stripeProductTierIDIsNil", "stripeProductTierIDNotNil", "stripeProductTierIDEqualFold", "stripeProductTierIDContainsFold", "stripeSubscriptionStatus", "stripeSubscriptionStatusNEQ", "stripeSubscriptionStatusIn", "stripeSubscriptionStatusNotIn", "stripeSubscriptionStatusGT", "stripeSubscriptionStatusGTE", "stripeSubscriptionStatusLT", "stripeSubscriptionStatusLTE", "stripeSubscriptionStatusContains", "stripeSubscriptionStatusHasPrefix", "stripeSubscriptionStatusHasSuffix", "stripeSubscriptionStatusIsNil", "stripeSubscriptionStatusNotNil", "stripeSubscriptionStatusEqualFold", "stripeSubscriptionStatusContainsFold", "active", "activeNEQ", "stripeCustomerID", "stripeCustomerIDNEQ", "stripeCustomerIDIn", "stripeCustomerIDNotIn", "stripeCustomerIDGT", "stripeCustomerIDGTE", "stripeCustomerIDLT", "stripeCustomerIDLTE", "stripeCustomerIDContains", "stripeCustomerIDHasPrefix", "stripeCustomerIDHasSuffix", "stripeCustomerIDIsNil", "stripeCustomerIDNotNil", "stripeCustomerIDEqualFold", "stripeCustomerIDContainsFold", "expiresAt", "expiresAtNEQ", "expiresAtIn", "expiresAtNotIn", "expiresAtGT", "expiresAtGTE", "expiresAtLT", "expiresAtLTE", "expiresAtIsNil", "expiresAtNotNil", "hasOwner", "hasOwnerWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -305155,21 +313030,21 @@ func (ec *executionContext) unmarshalInputOrgMembershipWhereInput(ctx context.Co switch k { case "not": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("not")) - data, err := ec.unmarshalOOrgMembershipWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipWhereInput(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionWhereInput(ctx, v) if err != nil { return it, err } it.Not = data case "and": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("and")) - data, err := ec.unmarshalOOrgMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionWhereInputᚄ(ctx, v) if err != nil { return it, err } it.And = data case "or": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("or")) - data, err := ec.unmarshalOOrgMembershipWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgMembershipWhereInputᚄ(ctx, v) + data, err := ec.unmarshalOOrgSubscriptionWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionWhereInputᚄ(ctx, v) if err != nil { return it, err } @@ -305769,48 +313644,734 @@ func (ec *executionContext) unmarshalInputOrgMembershipWhereInput(ctx context.Co return it, err } it.DeletedByContainsFold = data - case "role": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) - data, err := ec.unmarshalOOrgMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + case "ownerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.Role = data - case "roleNEQ": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNEQ")) - data, err := ec.unmarshalOOrgMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + it.OwnerID = data + case "ownerIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNEQ")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RoleNEQ = data - case "roleIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleIn")) - data, err := ec.unmarshalOOrgMembershipRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + it.OwnerIDNEQ = data + case "ownerIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RoleIn = data - case "roleNotIn": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("roleNotIn")) - data, err := ec.unmarshalOOrgMembershipRole2ᚕgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRoleᚄ(ctx, v) + it.OwnerIDIn = data + case "ownerIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotIn")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RoleNotIn = data - case "organizationID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("organizationID")) + it.OwnerIDNotIn = data + case "ownerIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDGT = data + case "ownerIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDGTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDGTE = data + case "ownerIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLT")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDLT = data + case "ownerIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDLTE")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDLTE = data + case "ownerIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContains")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDContains = data + case "ownerIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasPrefix")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDHasPrefix = data + case "ownerIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDHasSuffix")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDHasSuffix = data + case "ownerIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDIsNil = data + case "ownerIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDNotNil = data + case "ownerIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDEqualFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDEqualFold = data + case "ownerIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerIDContainsFold")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerIDContainsFold = data + case "stripeSubscriptionID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.OrganizationID = data - case "userID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("userID")) + it.StripeSubscriptionID = data + case "stripeSubscriptionIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDNEQ")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.UserID = data + it.StripeSubscriptionIDNEQ = data + case "stripeSubscriptionIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDIn = data + case "stripeSubscriptionIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDNotIn = data + case "stripeSubscriptionIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDGT = data + case "stripeSubscriptionIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDGTE = data + case "stripeSubscriptionIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDLT = data + case "stripeSubscriptionIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDLTE = data + case "stripeSubscriptionIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDContains = data + case "stripeSubscriptionIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDHasPrefix = data + case "stripeSubscriptionIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDHasSuffix = data + case "stripeSubscriptionIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDIsNil = data + case "stripeSubscriptionIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDNotNil = data + case "stripeSubscriptionIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDEqualFold = data + case "stripeSubscriptionIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionIDContainsFold = data + case "productTier": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTier")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTier = data + case "productTierNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierNEQ = data + case "productTierIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ProductTierIn = data + case "productTierNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ProductTierNotIn = data + case "productTierGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierGT = data + case "productTierGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierGTE = data + case "productTierLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierLT = data + case "productTierLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierLTE = data + case "productTierContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierContains = data + case "productTierHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierHasPrefix = data + case "productTierHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierHasSuffix = data + case "productTierIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ProductTierIsNil = data + case "productTierNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ProductTierNotNil = data + case "productTierEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierEqualFold = data + case "productTierContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTierContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ProductTierContainsFold = data + case "stripeProductTierID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierID = data + case "stripeProductTierIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDNEQ = data + case "stripeProductTierIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDIn = data + case "stripeProductTierIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDNotIn = data + case "stripeProductTierIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDGT = data + case "stripeProductTierIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDGTE = data + case "stripeProductTierIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDLT = data + case "stripeProductTierIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDLTE = data + case "stripeProductTierIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDContains = data + case "stripeProductTierIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDHasPrefix = data + case "stripeProductTierIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDHasSuffix = data + case "stripeProductTierIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDIsNil = data + case "stripeProductTierIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDNotNil = data + case "stripeProductTierIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDEqualFold = data + case "stripeProductTierIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeProductTierIDContainsFold = data + case "stripeSubscriptionStatus": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatus")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatus = data + case "stripeSubscriptionStatusNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusNEQ = data + case "stripeSubscriptionStatusIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusIn = data + case "stripeSubscriptionStatusNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusNotIn = data + case "stripeSubscriptionStatusGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusGT = data + case "stripeSubscriptionStatusGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusGTE = data + case "stripeSubscriptionStatusLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusLT = data + case "stripeSubscriptionStatusLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusLTE = data + case "stripeSubscriptionStatusContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusContains = data + case "stripeSubscriptionStatusHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusHasPrefix = data + case "stripeSubscriptionStatusHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusHasSuffix = data + case "stripeSubscriptionStatusIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusIsNil = data + case "stripeSubscriptionStatusNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusNotNil = data + case "stripeSubscriptionStatusEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusEqualFold = data + case "stripeSubscriptionStatusContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatusContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeSubscriptionStatusContainsFold = data + case "active": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("active")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.Active = data + case "activeNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("activeNEQ")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.ActiveNEQ = data + case "stripeCustomerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerID = data + case "stripeCustomerIDNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDNEQ")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDNEQ = data + case "stripeCustomerIDIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDIn = data + case "stripeCustomerIDNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDNotIn")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDNotIn = data + case "stripeCustomerIDGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDGT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDGT = data + case "stripeCustomerIDGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDGTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDGTE = data + case "stripeCustomerIDLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDLT")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDLT = data + case "stripeCustomerIDLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDLTE")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDLTE = data + case "stripeCustomerIDContains": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDContains")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDContains = data + case "stripeCustomerIDHasPrefix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDHasPrefix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDHasPrefix = data + case "stripeCustomerIDHasSuffix": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDHasSuffix")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDHasSuffix = data + case "stripeCustomerIDIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDIsNil = data + case "stripeCustomerIDNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDNotNil = data + case "stripeCustomerIDEqualFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDEqualFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDEqualFold = data + case "stripeCustomerIDContainsFold": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerIDContainsFold")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.StripeCustomerIDContainsFold = data + case "expiresAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAt")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAt = data + case "expiresAtNEQ": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtNEQ")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtNEQ = data + case "expiresAtIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtIn = data + case "expiresAtNotIn": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtNotIn")) + data, err := ec.unmarshalOTime2ᚕtimeᚐTimeᚄ(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtNotIn = data + case "expiresAtGT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtGT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtGT = data + case "expiresAtGTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtGTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtGTE = data + case "expiresAtLT": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtLT")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtLT = data + case "expiresAtLTE": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtLTE")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtLTE = data + case "expiresAtIsNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtIsNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtIsNil = data + case "expiresAtNotNil": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAtNotNil")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ExpiresAtNotNil = data + case "hasOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwner")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOwner = data + case "hasOwnerWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOwnerWith")) + data, err := ec.unmarshalOOrganizationWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOwnerWith = data } } @@ -310097,7 +318658,7 @@ func (ec *executionContext) unmarshalInputOrganizationWhereInput(ctx context.Con asMap[k] = v } - fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameEqualFold", "displayNameContainsFold", "parentOrganizationID", "parentOrganizationIDNEQ", "parentOrganizationIDIn", "parentOrganizationIDNotIn", "parentOrganizationIDGT", "parentOrganizationIDGTE", "parentOrganizationIDLT", "parentOrganizationIDLTE", "parentOrganizationIDContains", "parentOrganizationIDHasPrefix", "parentOrganizationIDHasSuffix", "parentOrganizationIDIsNil", "parentOrganizationIDNotNil", "parentOrganizationIDEqualFold", "parentOrganizationIDContainsFold", "personalOrg", "personalOrgNEQ", "personalOrgIsNil", "personalOrgNotNil", "avatarRemoteURL", "avatarRemoteURLNEQ", "avatarRemoteURLIn", "avatarRemoteURLNotIn", "avatarRemoteURLGT", "avatarRemoteURLGTE", "avatarRemoteURLLT", "avatarRemoteURLLTE", "avatarRemoteURLContains", "avatarRemoteURLHasPrefix", "avatarRemoteURLHasSuffix", "avatarRemoteURLIsNil", "avatarRemoteURLNotNil", "avatarRemoteURLEqualFold", "avatarRemoteURLContainsFold", "hasControlCreators", "hasControlCreatorsWith", "hasControlObjectiveCreators", "hasControlObjectiveCreatorsWith", "hasGroupCreators", "hasGroupCreatorsWith", "hasInternalPolicyCreators", "hasInternalPolicyCreatorsWith", "hasNarrativeCreators", "hasNarrativeCreatorsWith", "hasProcedureCreators", "hasProcedureCreatorsWith", "hasProgramCreators", "hasProgramCreatorsWith", "hasRiskCreators", "hasRiskCreatorsWith", "hasTemplateCreators", "hasTemplateCreatorsWith", "hasParent", "hasParentWith", "hasChildren", "hasChildrenWith", "hasGroups", "hasGroupsWith", "hasTemplates", "hasTemplatesWith", "hasIntegrations", "hasIntegrationsWith", "hasSetting", "hasSettingWith", "hasDocumentdata", "hasDocumentdataWith", "hasEntitlements", "hasEntitlementsWith", "hasOrganizationEntitlement", "hasOrganizationEntitlementWith", "hasPersonalAccessTokens", "hasPersonalAccessTokensWith", "hasAPITokens", "hasAPITokensWith", "hasOauthprovider", "hasOauthproviderWith", "hasUsers", "hasUsersWith", "hasInvites", "hasInvitesWith", "hasSubscribers", "hasSubscribersWith", "hasWebhooks", "hasWebhooksWith", "hasEvents", "hasEventsWith", "hasSecrets", "hasSecretsWith", "hasFeatures", "hasFeaturesWith", "hasFiles", "hasFilesWith", "hasEntitlementplans", "hasEntitlementplansWith", "hasEntitlementplanfeatures", "hasEntitlementplanfeaturesWith", "hasEntities", "hasEntitiesWith", "hasEntitytypes", "hasEntitytypesWith", "hasContacts", "hasContactsWith", "hasNotes", "hasNotesWith", "hasTasks", "hasTasksWith", "hasPrograms", "hasProgramsWith", "hasProcedures", "hasProceduresWith", "hasInternalpolicies", "hasInternalpoliciesWith", "hasRisks", "hasRisksWith", "hasControlobjectives", "hasControlobjectivesWith", "hasNarratives", "hasNarrativesWith", "hasControls", "hasControlsWith", "hasSubcontrols", "hasSubcontrolsWith", "hasMembers", "hasMembersWith"} + fieldsInOrder := [...]string{"not", "and", "or", "id", "idNEQ", "idIn", "idNotIn", "idGT", "idGTE", "idLT", "idLTE", "idEqualFold", "idContainsFold", "createdAt", "createdAtNEQ", "createdAtIn", "createdAtNotIn", "createdAtGT", "createdAtGTE", "createdAtLT", "createdAtLTE", "createdAtIsNil", "createdAtNotNil", "updatedAt", "updatedAtNEQ", "updatedAtIn", "updatedAtNotIn", "updatedAtGT", "updatedAtGTE", "updatedAtLT", "updatedAtLTE", "updatedAtIsNil", "updatedAtNotNil", "createdBy", "createdByNEQ", "createdByIn", "createdByNotIn", "createdByGT", "createdByGTE", "createdByLT", "createdByLTE", "createdByContains", "createdByHasPrefix", "createdByHasSuffix", "createdByIsNil", "createdByNotNil", "createdByEqualFold", "createdByContainsFold", "updatedBy", "updatedByNEQ", "updatedByIn", "updatedByNotIn", "updatedByGT", "updatedByGTE", "updatedByLT", "updatedByLTE", "updatedByContains", "updatedByHasPrefix", "updatedByHasSuffix", "updatedByIsNil", "updatedByNotNil", "updatedByEqualFold", "updatedByContainsFold", "deletedAt", "deletedAtNEQ", "deletedAtIn", "deletedAtNotIn", "deletedAtGT", "deletedAtGTE", "deletedAtLT", "deletedAtLTE", "deletedAtIsNil", "deletedAtNotNil", "deletedBy", "deletedByNEQ", "deletedByIn", "deletedByNotIn", "deletedByGT", "deletedByGTE", "deletedByLT", "deletedByLTE", "deletedByContains", "deletedByHasPrefix", "deletedByHasSuffix", "deletedByIsNil", "deletedByNotNil", "deletedByEqualFold", "deletedByContainsFold", "displayName", "displayNameNEQ", "displayNameIn", "displayNameNotIn", "displayNameGT", "displayNameGTE", "displayNameLT", "displayNameLTE", "displayNameContains", "displayNameHasPrefix", "displayNameHasSuffix", "displayNameEqualFold", "displayNameContainsFold", "parentOrganizationID", "parentOrganizationIDNEQ", "parentOrganizationIDIn", "parentOrganizationIDNotIn", "parentOrganizationIDGT", "parentOrganizationIDGTE", "parentOrganizationIDLT", "parentOrganizationIDLTE", "parentOrganizationIDContains", "parentOrganizationIDHasPrefix", "parentOrganizationIDHasSuffix", "parentOrganizationIDIsNil", "parentOrganizationIDNotNil", "parentOrganizationIDEqualFold", "parentOrganizationIDContainsFold", "personalOrg", "personalOrgNEQ", "personalOrgIsNil", "personalOrgNotNil", "avatarRemoteURL", "avatarRemoteURLNEQ", "avatarRemoteURLIn", "avatarRemoteURLNotIn", "avatarRemoteURLGT", "avatarRemoteURLGTE", "avatarRemoteURLLT", "avatarRemoteURLLTE", "avatarRemoteURLContains", "avatarRemoteURLHasPrefix", "avatarRemoteURLHasSuffix", "avatarRemoteURLIsNil", "avatarRemoteURLNotNil", "avatarRemoteURLEqualFold", "avatarRemoteURLContainsFold", "hasControlCreators", "hasControlCreatorsWith", "hasControlObjectiveCreators", "hasControlObjectiveCreatorsWith", "hasGroupCreators", "hasGroupCreatorsWith", "hasInternalPolicyCreators", "hasInternalPolicyCreatorsWith", "hasNarrativeCreators", "hasNarrativeCreatorsWith", "hasProcedureCreators", "hasProcedureCreatorsWith", "hasProgramCreators", "hasProgramCreatorsWith", "hasRiskCreators", "hasRiskCreatorsWith", "hasTemplateCreators", "hasTemplateCreatorsWith", "hasParent", "hasParentWith", "hasChildren", "hasChildrenWith", "hasGroups", "hasGroupsWith", "hasTemplates", "hasTemplatesWith", "hasIntegrations", "hasIntegrationsWith", "hasSetting", "hasSettingWith", "hasDocumentdata", "hasDocumentdataWith", "hasEntitlements", "hasEntitlementsWith", "hasOrgsubscriptions", "hasOrgsubscriptionsWith", "hasOrganizationEntitlement", "hasOrganizationEntitlementWith", "hasPersonalAccessTokens", "hasPersonalAccessTokensWith", "hasAPITokens", "hasAPITokensWith", "hasOauthprovider", "hasOauthproviderWith", "hasUsers", "hasUsersWith", "hasInvites", "hasInvitesWith", "hasSubscribers", "hasSubscribersWith", "hasWebhooks", "hasWebhooksWith", "hasEvents", "hasEventsWith", "hasSecrets", "hasSecretsWith", "hasFeatures", "hasFeaturesWith", "hasFiles", "hasFilesWith", "hasEntitlementplans", "hasEntitlementplansWith", "hasEntitlementplanfeatures", "hasEntitlementplanfeaturesWith", "hasEntities", "hasEntitiesWith", "hasEntitytypes", "hasEntitytypesWith", "hasContacts", "hasContactsWith", "hasNotes", "hasNotesWith", "hasTasks", "hasTasksWith", "hasPrograms", "hasProgramsWith", "hasProcedures", "hasProceduresWith", "hasInternalpolicies", "hasInternalpoliciesWith", "hasRisks", "hasRisksWith", "hasControlobjectives", "hasControlobjectivesWith", "hasNarratives", "hasNarrativesWith", "hasControls", "hasControlsWith", "hasSubcontrols", "hasSubcontrolsWith", "hasMembers", "hasMembersWith"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -311287,6 +319848,20 @@ func (ec *executionContext) unmarshalInputOrganizationWhereInput(ctx context.Con return it, err } it.HasEntitlementsWith = data + case "hasOrgsubscriptions": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrgsubscriptions")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.HasOrgsubscriptions = data + case "hasOrgsubscriptionsWith": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrgsubscriptionsWith")) + data, err := ec.unmarshalOOrgSubscriptionWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionWhereInputᚄ(ctx, v) + if err != nil { + return it, err + } + it.HasOrgsubscriptionsWith = data case "hasOrganizationEntitlement": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("hasOrganizationEntitlement")) data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) @@ -343736,340 +352311,507 @@ func (ec *executionContext) unmarshalInputUpdateOauthProviderInput(ctx context.C return it, err } it.ClearTags = data - case "name": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Name = data - case "clientID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClientID = data - case "clientSecret": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecret")) + case "name": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Name = data + case "clientID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientID = data + case "clientSecret": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientSecret")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientSecret = data + case "redirectURL": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURL")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.RedirectURL = data + case "scopes": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopes")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Scopes = data + case "authURL": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURL")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.AuthURL = data + case "tokenURL": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURL")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.TokenURL = data + case "authStyle": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyle")) + data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) + if err != nil { + return it, err + } + it.AuthStyle = data + case "infoURL": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURL")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.InfoURL = data + case "ownerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.OwnerID = data + case "clearOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearOwner")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearOwner = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputUpdateOhAuthTooTokenInput(ctx context.Context, obj interface{}) (generated.UpdateOhAuthTooTokenInput, error) { + var it generated.UpdateOhAuthTooTokenInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"tags", "appendTags", "clearTags", "clientID", "scopes", "appendScopes", "clearScopes", "nonce", "claimsUserID", "claimsUsername", "claimsEmail", "claimsEmailVerified", "claimsGroups", "appendClaimsGroups", "clearClaimsGroups", "claimsPreferredUsername", "connectorID", "connectorData", "appendConnectorData", "clearConnectorData", "lastUsed", "addIntegrationIDs", "removeIntegrationIDs", "clearIntegration", "addEventIDs", "removeEventIDs", "clearEvents"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "tags": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tags")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.Tags = data + case "appendTags": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendTags")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AppendTags = data + case "clearTags": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearTags")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearTags = data + case "clientID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClientID = data + case "scopes": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopes")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.Scopes = data + case "appendScopes": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendScopes")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AppendScopes = data + case "clearScopes": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearScopes")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearScopes = data + case "nonce": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonce")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.Nonce = data + case "claimsUserID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUserID = data + case "claimsUsername": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsername")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsUsername = data + case "claimsEmail": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmail")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmail = data + case "claimsEmailVerified": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailVerified")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) + if err != nil { + return it, err + } + it.ClaimsEmailVerified = data + case "claimsGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsGroups")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ClaimsGroups = data + case "appendClaimsGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendClaimsGroups")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AppendClaimsGroups = data + case "clearClaimsGroups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearClaimsGroups")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearClaimsGroups = data + case "claimsPreferredUsername": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsername")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ClaimsPreferredUsername = data + case "connectorID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorID")) + data, err := ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } + it.ConnectorID = data + case "connectorData": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorData")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.ConnectorData = data + case "appendConnectorData": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendConnectorData")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AppendConnectorData = data + case "clearConnectorData": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearConnectorData")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearConnectorData = data + case "lastUsed": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsed")) + data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) + if err != nil { + return it, err + } + it.LastUsed = data + case "addIntegrationIDs": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addIntegrationIDs")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AddIntegrationIDs = data + case "removeIntegrationIDs": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("removeIntegrationIDs")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RemoveIntegrationIDs = data + case "clearIntegration": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearIntegration")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearIntegration = data + case "addEventIDs": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addEventIDs")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AddEventIDs = data + case "removeEventIDs": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("removeEventIDs")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RemoveEventIDs = data + case "clearEvents": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearEvents")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearEvents = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputUpdateOrgMembershipInput(ctx context.Context, obj interface{}) (generated.UpdateOrgMembershipInput, error) { + var it generated.UpdateOrgMembershipInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"role", "addEventIDs", "removeEventIDs", "clearEvents"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "role": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) + data, err := ec.unmarshalOOrgMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) + if err != nil { + return it, err + } + it.Role = data + case "addEventIDs": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addEventIDs")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AddEventIDs = data + case "removeEventIDs": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("removeEventIDs")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RemoveEventIDs = data + case "clearEvents": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearEvents")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearEvents = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputUpdateOrgSubscriptionInput(ctx context.Context, obj interface{}) (generated.UpdateOrgSubscriptionInput, error) { + var it generated.UpdateOrgSubscriptionInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"tags", "appendTags", "clearTags", "stripeSubscriptionID", "clearStripeSubscriptionID", "productTier", "clearProductTier", "stripeProductTierID", "clearStripeProductTierID", "stripeSubscriptionStatus", "clearStripeSubscriptionStatus", "active", "stripeCustomerID", "clearStripeCustomerID", "expiresAt", "clearExpiresAt", "features", "appendFeatures", "clearFeatures", "ownerID", "clearOwner"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "tags": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tags")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.Tags = data + case "appendTags": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendTags")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AppendTags = data + case "clearTags": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearTags")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearTags = data + case "stripeSubscriptionID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClientSecret = data - case "redirectURL": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("redirectURL")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.RedirectURL = data - case "scopes": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopes")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.Scopes = data - case "authURL": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authURL")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.AuthURL = data - case "tokenURL": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tokenURL")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.TokenURL = data - case "authStyle": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("authStyle")) - data, err := ec.unmarshalOUint2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋcustomtypesᚐUint8(ctx, v) - if err != nil { - return it, err - } - it.AuthStyle = data - case "infoURL": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("infoURL")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.InfoURL = data - case "ownerID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) - data, err := ec.unmarshalOID2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.OwnerID = data - case "clearOwner": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearOwner")) + it.StripeSubscriptionID = data + case "clearStripeSubscriptionID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearStripeSubscriptionID")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClearOwner = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputUpdateOhAuthTooTokenInput(ctx context.Context, obj interface{}) (generated.UpdateOhAuthTooTokenInput, error) { - var it generated.UpdateOhAuthTooTokenInput - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - fieldsInOrder := [...]string{"tags", "appendTags", "clearTags", "clientID", "scopes", "appendScopes", "clearScopes", "nonce", "claimsUserID", "claimsUsername", "claimsEmail", "claimsEmailVerified", "claimsGroups", "appendClaimsGroups", "clearClaimsGroups", "claimsPreferredUsername", "connectorID", "connectorData", "appendConnectorData", "clearConnectorData", "lastUsed", "addIntegrationIDs", "removeIntegrationIDs", "clearIntegration", "addEventIDs", "removeEventIDs", "clearEvents"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "tags": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tags")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.Tags = data - case "appendTags": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendTags")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.AppendTags = data - case "clearTags": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearTags")) - data, err := ec.unmarshalOBoolean2bool(ctx, v) - if err != nil { - return it, err - } - it.ClearTags = data - case "clientID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientID")) + it.ClearStripeSubscriptionID = data + case "productTier": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("productTier")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClientID = data - case "scopes": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopes")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.Scopes = data - case "appendScopes": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendScopes")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.AppendScopes = data - case "clearScopes": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearScopes")) + it.ProductTier = data + case "clearProductTier": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearProductTier")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClearScopes = data - case "nonce": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nonce")) + it.ClearProductTier = data + case "stripeProductTierID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeProductTierID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.Nonce = data - case "claimsUserID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUserID")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) - if err != nil { - return it, err - } - it.ClaimsUserID = data - case "claimsUsername": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsUsername")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.StripeProductTierID = data + case "clearStripeProductTierID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearStripeProductTierID")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClaimsUsername = data - case "claimsEmail": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmail")) + it.ClearStripeProductTierID = data + case "stripeSubscriptionStatus": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeSubscriptionStatus")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ClaimsEmail = data - case "claimsEmailVerified": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsEmailVerified")) - data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) - if err != nil { - return it, err - } - it.ClaimsEmailVerified = data - case "claimsGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsGroups")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ClaimsGroups = data - case "appendClaimsGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendClaimsGroups")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.AppendClaimsGroups = data - case "clearClaimsGroups": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearClaimsGroups")) + it.StripeSubscriptionStatus = data + case "clearStripeSubscriptionStatus": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearStripeSubscriptionStatus")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClearClaimsGroups = data - case "claimsPreferredUsername": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("claimsPreferredUsername")) - data, err := ec.unmarshalOString2ᚖstring(ctx, v) + it.ClearStripeSubscriptionStatus = data + case "active": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("active")) + data, err := ec.unmarshalOBoolean2ᚖbool(ctx, v) if err != nil { return it, err } - it.ClaimsPreferredUsername = data - case "connectorID": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorID")) + it.Active = data + case "stripeCustomerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("stripeCustomerID")) data, err := ec.unmarshalOString2ᚖstring(ctx, v) if err != nil { return it, err } - it.ConnectorID = data - case "connectorData": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("connectorData")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.ConnectorData = data - case "appendConnectorData": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendConnectorData")) - data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.AppendConnectorData = data - case "clearConnectorData": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearConnectorData")) + it.StripeCustomerID = data + case "clearStripeCustomerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearStripeCustomerID")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClearConnectorData = data - case "lastUsed": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("lastUsed")) + it.ClearStripeCustomerID = data + case "expiresAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("expiresAt")) data, err := ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v) if err != nil { return it, err } - it.LastUsed = data - case "addIntegrationIDs": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addIntegrationIDs")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.AddIntegrationIDs = data - case "removeIntegrationIDs": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("removeIntegrationIDs")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.RemoveIntegrationIDs = data - case "clearIntegration": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearIntegration")) + it.ExpiresAt = data + case "clearExpiresAt": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearExpiresAt")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClearIntegration = data - case "addEventIDs": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addEventIDs")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.ClearExpiresAt = data + case "features": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("features")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.AddEventIDs = data - case "removeEventIDs": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("removeEventIDs")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.Features = data + case "appendFeatures": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("appendFeatures")) + data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v) if err != nil { return it, err } - it.RemoveEventIDs = data - case "clearEvents": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearEvents")) + it.AppendFeatures = data + case "clearFeatures": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearFeatures")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClearEvents = data - } - } - - return it, nil -} - -func (ec *executionContext) unmarshalInputUpdateOrgMembershipInput(ctx context.Context, obj interface{}) (generated.UpdateOrgMembershipInput, error) { - var it generated.UpdateOrgMembershipInput - asMap := map[string]interface{}{} - for k, v := range obj.(map[string]interface{}) { - asMap[k] = v - } - - fieldsInOrder := [...]string{"role", "addEventIDs", "removeEventIDs", "clearEvents"} - for _, k := range fieldsInOrder { - v, ok := asMap[k] - if !ok { - continue - } - switch k { - case "role": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("role")) - data, err := ec.unmarshalOOrgMembershipRole2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋpkgᚋenumsᚐRole(ctx, v) - if err != nil { - return it, err - } - it.Role = data - case "addEventIDs": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addEventIDs")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) - if err != nil { - return it, err - } - it.AddEventIDs = data - case "removeEventIDs": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("removeEventIDs")) - data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + it.ClearFeatures = data + case "ownerID": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("ownerID")) + data, err := ec.unmarshalOID2ᚖstring(ctx, v) if err != nil { return it, err } - it.RemoveEventIDs = data - case "clearEvents": - ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearEvents")) + it.OwnerID = data + case "clearOwner": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearOwner")) data, err := ec.unmarshalOBoolean2bool(ctx, v) if err != nil { return it, err } - it.ClearEvents = data + it.ClearOwner = data } } @@ -344083,7 +352825,7 @@ func (ec *executionContext) unmarshalInputUpdateOrganizationInput(ctx context.Co asMap[k] = v } - fieldsInOrder := [...]string{"tags", "appendTags", "clearTags", "name", "displayName", "description", "clearDescription", "avatarRemoteURL", "clearAvatarRemoteURL", "addControlCreatorIDs", "removeControlCreatorIDs", "clearControlCreators", "addControlObjectiveCreatorIDs", "removeControlObjectiveCreatorIDs", "clearControlObjectiveCreators", "addGroupCreatorIDs", "removeGroupCreatorIDs", "clearGroupCreators", "addInternalPolicyCreatorIDs", "removeInternalPolicyCreatorIDs", "clearInternalPolicyCreators", "addNarrativeCreatorIDs", "removeNarrativeCreatorIDs", "clearNarrativeCreators", "addProcedureCreatorIDs", "removeProcedureCreatorIDs", "clearProcedureCreators", "addProgramCreatorIDs", "removeProgramCreatorIDs", "clearProgramCreators", "addRiskCreatorIDs", "removeRiskCreatorIDs", "clearRiskCreators", "addTemplateCreatorIDs", "removeTemplateCreatorIDs", "clearTemplateCreators", "addGroupIDs", "removeGroupIDs", "clearGroups", "addTemplateIDs", "removeTemplateIDs", "clearTemplates", "addIntegrationIDs", "removeIntegrationIDs", "clearIntegrations", "settingID", "clearSetting", "addDocumentdatumIDs", "removeDocumentdatumIDs", "clearDocumentdata", "addEntitlementIDs", "removeEntitlementIDs", "clearEntitlements", "addOrganizationEntitlementIDs", "removeOrganizationEntitlementIDs", "clearOrganizationEntitlement", "addPersonalAccessTokenIDs", "removePersonalAccessTokenIDs", "clearPersonalAccessTokens", "addAPITokenIDs", "removeAPITokenIDs", "clearAPITokens", "addOauthproviderIDs", "removeOauthproviderIDs", "clearOauthprovider", "addUserIDs", "removeUserIDs", "clearUsers", "addInviteIDs", "removeInviteIDs", "clearInvites", "addSubscriberIDs", "removeSubscriberIDs", "clearSubscribers", "addWebhookIDs", "removeWebhookIDs", "clearWebhooks", "addEventIDs", "removeEventIDs", "clearEvents", "addSecretIDs", "removeSecretIDs", "clearSecrets", "addFeatureIDs", "removeFeatureIDs", "clearFeatures", "addFileIDs", "removeFileIDs", "clearFiles", "addEntitlementplanIDs", "removeEntitlementplanIDs", "clearEntitlementplans", "addEntityIDs", "removeEntityIDs", "clearEntities", "addEntitytypeIDs", "removeEntitytypeIDs", "clearEntitytypes", "addContactIDs", "removeContactIDs", "clearContacts", "addNoteIDs", "removeNoteIDs", "clearNotes", "addTaskIDs", "removeTaskIDs", "clearTasks", "addProgramIDs", "removeProgramIDs", "clearPrograms", "addProcedureIDs", "removeProcedureIDs", "clearProcedures", "addInternalpolicyIDs", "removeInternalpolicyIDs", "clearInternalpolicies", "addRiskIDs", "removeRiskIDs", "clearRisks", "addControlobjectiveIDs", "removeControlobjectiveIDs", "clearControlobjectives", "addNarrativeIDs", "removeNarrativeIDs", "clearNarratives", "addControlIDs", "removeControlIDs", "clearControls", "addSubcontrolIDs", "removeSubcontrolIDs", "clearSubcontrols", "addOrgMembers", "updateOrgSettings"} + fieldsInOrder := [...]string{"tags", "appendTags", "clearTags", "name", "displayName", "description", "clearDescription", "avatarRemoteURL", "clearAvatarRemoteURL", "addControlCreatorIDs", "removeControlCreatorIDs", "clearControlCreators", "addControlObjectiveCreatorIDs", "removeControlObjectiveCreatorIDs", "clearControlObjectiveCreators", "addGroupCreatorIDs", "removeGroupCreatorIDs", "clearGroupCreators", "addInternalPolicyCreatorIDs", "removeInternalPolicyCreatorIDs", "clearInternalPolicyCreators", "addNarrativeCreatorIDs", "removeNarrativeCreatorIDs", "clearNarrativeCreators", "addProcedureCreatorIDs", "removeProcedureCreatorIDs", "clearProcedureCreators", "addProgramCreatorIDs", "removeProgramCreatorIDs", "clearProgramCreators", "addRiskCreatorIDs", "removeRiskCreatorIDs", "clearRiskCreators", "addTemplateCreatorIDs", "removeTemplateCreatorIDs", "clearTemplateCreators", "addGroupIDs", "removeGroupIDs", "clearGroups", "addTemplateIDs", "removeTemplateIDs", "clearTemplates", "addIntegrationIDs", "removeIntegrationIDs", "clearIntegrations", "settingID", "clearSetting", "addDocumentdatumIDs", "removeDocumentdatumIDs", "clearDocumentdata", "addEntitlementIDs", "removeEntitlementIDs", "clearEntitlements", "addOrgsubscriptionIDs", "removeOrgsubscriptionIDs", "clearOrgsubscriptions", "addOrganizationEntitlementIDs", "removeOrganizationEntitlementIDs", "clearOrganizationEntitlement", "addPersonalAccessTokenIDs", "removePersonalAccessTokenIDs", "clearPersonalAccessTokens", "addAPITokenIDs", "removeAPITokenIDs", "clearAPITokens", "addOauthproviderIDs", "removeOauthproviderIDs", "clearOauthprovider", "addUserIDs", "removeUserIDs", "clearUsers", "addInviteIDs", "removeInviteIDs", "clearInvites", "addSubscriberIDs", "removeSubscriberIDs", "clearSubscribers", "addWebhookIDs", "removeWebhookIDs", "clearWebhooks", "addEventIDs", "removeEventIDs", "clearEvents", "addSecretIDs", "removeSecretIDs", "clearSecrets", "addFeatureIDs", "removeFeatureIDs", "clearFeatures", "addFileIDs", "removeFileIDs", "clearFiles", "addEntitlementplanIDs", "removeEntitlementplanIDs", "clearEntitlementplans", "addEntityIDs", "removeEntityIDs", "clearEntities", "addEntitytypeIDs", "removeEntitytypeIDs", "clearEntitytypes", "addContactIDs", "removeContactIDs", "clearContacts", "addNoteIDs", "removeNoteIDs", "clearNotes", "addTaskIDs", "removeTaskIDs", "clearTasks", "addProgramIDs", "removeProgramIDs", "clearPrograms", "addProcedureIDs", "removeProcedureIDs", "clearProcedures", "addInternalpolicyIDs", "removeInternalpolicyIDs", "clearInternalpolicies", "addRiskIDs", "removeRiskIDs", "clearRisks", "addControlobjectiveIDs", "removeControlobjectiveIDs", "clearControlobjectives", "addNarrativeIDs", "removeNarrativeIDs", "clearNarratives", "addControlIDs", "removeControlIDs", "clearControls", "addSubcontrolIDs", "removeSubcontrolIDs", "clearSubcontrols", "addOrgMembers", "updateOrgSettings"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -344461,6 +353203,27 @@ func (ec *executionContext) unmarshalInputUpdateOrganizationInput(ctx context.Co return it, err } it.ClearEntitlements = data + case "addOrgsubscriptionIDs": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addOrgsubscriptionIDs")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.AddOrgsubscriptionIDs = data + case "removeOrgsubscriptionIDs": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("removeOrgsubscriptionIDs")) + data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) + if err != nil { + return it, err + } + it.RemoveOrgsubscriptionIDs = data + case "clearOrgsubscriptions": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clearOrgsubscriptions")) + data, err := ec.unmarshalOBoolean2bool(ctx, v) + if err != nil { + return it, err + } + it.ClearOrgsubscriptions = data case "addOrganizationEntitlementIDs": ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("addOrganizationEntitlementIDs")) data, err := ec.unmarshalOID2ᚕstringᚄ(ctx, v) @@ -357655,6 +366418,16 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._OrgMembershipHistory(ctx, sel, obj) + case *generated.OrgSubscription: + if obj == nil { + return graphql.Null + } + return ec._OrgSubscription(ctx, sel, obj) + case *generated.OrgSubscriptionHistory: + if obj == nil { + return graphql.Null + } + return ec._OrgSubscriptionHistory(ctx, sel, obj) case *generated.Organization: if obj == nil { return graphql.Null @@ -357956,6 +366729,13 @@ func (ec *executionContext) _SearchResult(ctx context.Context, sel ast.Selection return graphql.Null } return ec._OhAuthTooTokenSearchResult(ctx, sel, obj) + case OrgSubscriptionSearchResult: + return ec._OrgSubscriptionSearchResult(ctx, sel, &obj) + case *OrgSubscriptionSearchResult: + if obj == nil { + return graphql.Null + } + return ec._OrgSubscriptionSearchResult(ctx, sel, obj) case OrganizationSearchResult: return ec._OrganizationSearchResult(ctx, sel, &obj) case *OrganizationSearchResult: @@ -374502,6 +383282,41 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) if out.Values[i] == graphql.Null { out.Invalids++ } + case "createOrgSubscription": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_createOrgSubscription(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createBulkOrgSubscription": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_createBulkOrgSubscription(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createBulkCSVOrgSubscription": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_createBulkCSVOrgSubscription(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "updateOrgSubscription": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_updateOrgSubscription(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "deleteOrgSubscription": + out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { + return ec._Mutation_deleteOrgSubscription(ctx, field) + }) + if out.Values[i] == graphql.Null { + out.Invalids++ + } case "createPersonalAccessToken": out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) { return ec._Mutation_createPersonalAccessToken(ctx, field) @@ -377248,19 +386063,595 @@ func (ec *executionContext) _OhAuthTooTokenSearchResult(ctx context.Context, sel return out } -var ohAuthTooTokenUpdatePayloadImplementors = []string{"OhAuthTooTokenUpdatePayload"} +var ohAuthTooTokenUpdatePayloadImplementors = []string{"OhAuthTooTokenUpdatePayload"} + +func (ec *executionContext) _OhAuthTooTokenUpdatePayload(ctx context.Context, sel ast.SelectionSet, obj *OhAuthTooTokenUpdatePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, ohAuthTooTokenUpdatePayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OhAuthTooTokenUpdatePayload") + case "ohAuthTooToken": + out.Values[i] = ec._OhAuthTooTokenUpdatePayload_ohAuthTooToken(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipImplementors = []string{"OrgMembership", "Node"} + +func (ec *executionContext) _OrgMembership(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembership) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgMembership") + case "id": + out.Values[i] = ec._OrgMembership_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "createdAt": + out.Values[i] = ec._OrgMembership_createdAt(ctx, field, obj) + case "updatedAt": + out.Values[i] = ec._OrgMembership_updatedAt(ctx, field, obj) + case "createdBy": + out.Values[i] = ec._OrgMembership_createdBy(ctx, field, obj) + case "updatedBy": + out.Values[i] = ec._OrgMembership_updatedBy(ctx, field, obj) + case "deletedAt": + out.Values[i] = ec._OrgMembership_deletedAt(ctx, field, obj) + case "deletedBy": + out.Values[i] = ec._OrgMembership_deletedBy(ctx, field, obj) + case "role": + out.Values[i] = ec._OrgMembership_role(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "organizationID": + out.Values[i] = ec._OrgMembership_organizationID(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "userID": + out.Values[i] = ec._OrgMembership_userID(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "organization": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._OrgMembership_organization(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "user": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._OrgMembership_user(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "events": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._OrgMembership_events(ctx, field, obj) + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipBulkCreatePayloadImplementors = []string{"OrgMembershipBulkCreatePayload"} + +func (ec *executionContext) _OrgMembershipBulkCreatePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgMembershipBulkCreatePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipBulkCreatePayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgMembershipBulkCreatePayload") + case "orgMemberships": + out.Values[i] = ec._OrgMembershipBulkCreatePayload_orgMemberships(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipConnectionImplementors = []string{"OrgMembershipConnection"} + +func (ec *executionContext) _OrgMembershipConnection(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipConnectionImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgMembershipConnection") + case "edges": + out.Values[i] = ec._OrgMembershipConnection_edges(ctx, field, obj) + case "pageInfo": + out.Values[i] = ec._OrgMembershipConnection_pageInfo(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "totalCount": + out.Values[i] = ec._OrgMembershipConnection_totalCount(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipCreatePayloadImplementors = []string{"OrgMembershipCreatePayload"} + +func (ec *executionContext) _OrgMembershipCreatePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgMembershipCreatePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipCreatePayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgMembershipCreatePayload") + case "orgMembership": + out.Values[i] = ec._OrgMembershipCreatePayload_orgMembership(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipDeletePayloadImplementors = []string{"OrgMembershipDeletePayload"} + +func (ec *executionContext) _OrgMembershipDeletePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgMembershipDeletePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipDeletePayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgMembershipDeletePayload") + case "deletedID": + out.Values[i] = ec._OrgMembershipDeletePayload_deletedID(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipEdgeImplementors = []string{"OrgMembershipEdge"} + +func (ec *executionContext) _OrgMembershipEdge(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipEdgeImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgMembershipEdge") + case "node": + out.Values[i] = ec._OrgMembershipEdge_node(ctx, field, obj) + case "cursor": + out.Values[i] = ec._OrgMembershipEdge_cursor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipHistoryImplementors = []string{"OrgMembershipHistory", "Node"} + +func (ec *executionContext) _OrgMembershipHistory(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipHistory) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipHistoryImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgMembershipHistory") + case "id": + out.Values[i] = ec._OrgMembershipHistory_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "historyTime": + out.Values[i] = ec._OrgMembershipHistory_historyTime(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "ref": + out.Values[i] = ec._OrgMembershipHistory_ref(ctx, field, obj) + case "operation": + out.Values[i] = ec._OrgMembershipHistory_operation(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._OrgMembershipHistory_createdAt(ctx, field, obj) + case "updatedAt": + out.Values[i] = ec._OrgMembershipHistory_updatedAt(ctx, field, obj) + case "createdBy": + out.Values[i] = ec._OrgMembershipHistory_createdBy(ctx, field, obj) + case "updatedBy": + out.Values[i] = ec._OrgMembershipHistory_updatedBy(ctx, field, obj) + case "deletedAt": + out.Values[i] = ec._OrgMembershipHistory_deletedAt(ctx, field, obj) + case "deletedBy": + out.Values[i] = ec._OrgMembershipHistory_deletedBy(ctx, field, obj) + case "role": + out.Values[i] = ec._OrgMembershipHistory_role(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "organizationID": + out.Values[i] = ec._OrgMembershipHistory_organizationID(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "userID": + out.Values[i] = ec._OrgMembershipHistory_userID(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipHistoryConnectionImplementors = []string{"OrgMembershipHistoryConnection"} + +func (ec *executionContext) _OrgMembershipHistoryConnection(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipHistoryConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipHistoryConnectionImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgMembershipHistoryConnection") + case "edges": + out.Values[i] = ec._OrgMembershipHistoryConnection_edges(ctx, field, obj) + case "pageInfo": + out.Values[i] = ec._OrgMembershipHistoryConnection_pageInfo(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "totalCount": + out.Values[i] = ec._OrgMembershipHistoryConnection_totalCount(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipHistoryEdgeImplementors = []string{"OrgMembershipHistoryEdge"} + +func (ec *executionContext) _OrgMembershipHistoryEdge(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipHistoryEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipHistoryEdgeImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgMembershipHistoryEdge") + case "node": + out.Values[i] = ec._OrgMembershipHistoryEdge_node(ctx, field, obj) + case "cursor": + out.Values[i] = ec._OrgMembershipHistoryEdge_cursor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgMembershipUpdatePayloadImplementors = []string{"OrgMembershipUpdatePayload"} -func (ec *executionContext) _OhAuthTooTokenUpdatePayload(ctx context.Context, sel ast.SelectionSet, obj *OhAuthTooTokenUpdatePayload) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, ohAuthTooTokenUpdatePayloadImplementors) +func (ec *executionContext) _OrgMembershipUpdatePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgMembershipUpdatePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipUpdatePayloadImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OhAuthTooTokenUpdatePayload") - case "ohAuthTooToken": - out.Values[i] = ec._OhAuthTooTokenUpdatePayload_ohAuthTooToken(ctx, field, obj) + out.Values[i] = graphql.MarshalString("OrgMembershipUpdatePayload") + case "orgMembership": + out.Values[i] = ec._OrgMembershipUpdatePayload_orgMembership(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -377287,122 +386678,58 @@ func (ec *executionContext) _OhAuthTooTokenUpdatePayload(ctx context.Context, se return out } -var orgMembershipImplementors = []string{"OrgMembership", "Node"} +var orgSubscriptionImplementors = []string{"OrgSubscription", "Node"} -func (ec *executionContext) _OrgMembership(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembership) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipImplementors) +func (ec *executionContext) _OrgSubscription(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgSubscription) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembership") + out.Values[i] = graphql.MarshalString("OrgSubscription") case "id": - out.Values[i] = ec._OrgMembership_id(ctx, field, obj) + out.Values[i] = ec._OrgSubscription_id(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } case "createdAt": - out.Values[i] = ec._OrgMembership_createdAt(ctx, field, obj) + out.Values[i] = ec._OrgSubscription_createdAt(ctx, field, obj) case "updatedAt": - out.Values[i] = ec._OrgMembership_updatedAt(ctx, field, obj) + out.Values[i] = ec._OrgSubscription_updatedAt(ctx, field, obj) case "createdBy": - out.Values[i] = ec._OrgMembership_createdBy(ctx, field, obj) + out.Values[i] = ec._OrgSubscription_createdBy(ctx, field, obj) case "updatedBy": - out.Values[i] = ec._OrgMembership_updatedBy(ctx, field, obj) + out.Values[i] = ec._OrgSubscription_updatedBy(ctx, field, obj) + case "tags": + out.Values[i] = ec._OrgSubscription_tags(ctx, field, obj) case "deletedAt": - out.Values[i] = ec._OrgMembership_deletedAt(ctx, field, obj) + out.Values[i] = ec._OrgSubscription_deletedAt(ctx, field, obj) case "deletedBy": - out.Values[i] = ec._OrgMembership_deletedBy(ctx, field, obj) - case "role": - out.Values[i] = ec._OrgMembership_role(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "organizationID": - out.Values[i] = ec._OrgMembership_organizationID(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "userID": - out.Values[i] = ec._OrgMembership_userID(ctx, field, obj) + out.Values[i] = ec._OrgSubscription_deletedBy(ctx, field, obj) + case "ownerID": + out.Values[i] = ec._OrgSubscription_ownerID(ctx, field, obj) + case "stripeSubscriptionID": + out.Values[i] = ec._OrgSubscription_stripeSubscriptionID(ctx, field, obj) + case "productTier": + out.Values[i] = ec._OrgSubscription_productTier(ctx, field, obj) + case "stripeProductTierID": + out.Values[i] = ec._OrgSubscription_stripeProductTierID(ctx, field, obj) + case "stripeSubscriptionStatus": + out.Values[i] = ec._OrgSubscription_stripeSubscriptionStatus(ctx, field, obj) + case "active": + out.Values[i] = ec._OrgSubscription_active(ctx, field, obj) if out.Values[i] == graphql.Null { atomic.AddUint32(&out.Invalids, 1) } - case "organization": - field := field - - innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._OrgMembership_organization(ctx, field, obj) - if res == graphql.Null { - atomic.AddUint32(&fs.Invalids, 1) - } - return res - } - - if field.Deferrable != nil { - dfs, ok := deferred[field.Deferrable.Label] - di := 0 - if ok { - dfs.AddField(field) - di = len(dfs.Values) - 1 - } else { - dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) - deferred[field.Deferrable.Label] = dfs - } - dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { - return innerFunc(ctx, dfs) - }) - - // don't run the out.Concurrently() call below - out.Values[i] = graphql.Null - continue - } - - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "user": - field := field - - innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._OrgMembership_user(ctx, field, obj) - if res == graphql.Null { - atomic.AddUint32(&fs.Invalids, 1) - } - return res - } - - if field.Deferrable != nil { - dfs, ok := deferred[field.Deferrable.Label] - di := 0 - if ok { - dfs.AddField(field) - di = len(dfs.Values) - 1 - } else { - dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) - deferred[field.Deferrable.Label] = dfs - } - dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { - return innerFunc(ctx, dfs) - }) - - // don't run the out.Concurrently() call below - out.Values[i] = graphql.Null - continue - } - - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "events": + case "stripeCustomerID": + out.Values[i] = ec._OrgSubscription_stripeCustomerID(ctx, field, obj) + case "expiresAt": + out.Values[i] = ec._OrgSubscription_expiresAt(ctx, field, obj) + case "features": + out.Values[i] = ec._OrgSubscription_features(ctx, field, obj) + case "owner": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -377411,7 +386738,7 @@ func (ec *executionContext) _OrgMembership(ctx context.Context, sel ast.Selectio ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._OrgMembership_events(ctx, field, obj) + res = ec._OrgSubscription_owner(ctx, field, obj) return res } @@ -377458,19 +386785,19 @@ func (ec *executionContext) _OrgMembership(ctx context.Context, sel ast.Selectio return out } -var orgMembershipBulkCreatePayloadImplementors = []string{"OrgMembershipBulkCreatePayload"} +var orgSubscriptionBulkCreatePayloadImplementors = []string{"OrgSubscriptionBulkCreatePayload"} -func (ec *executionContext) _OrgMembershipBulkCreatePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgMembershipBulkCreatePayload) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipBulkCreatePayloadImplementors) +func (ec *executionContext) _OrgSubscriptionBulkCreatePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgSubscriptionBulkCreatePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionBulkCreatePayloadImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembershipBulkCreatePayload") - case "orgMemberships": - out.Values[i] = ec._OrgMembershipBulkCreatePayload_orgMemberships(ctx, field, obj) + out.Values[i] = graphql.MarshalString("OrgSubscriptionBulkCreatePayload") + case "orgSubscriptions": + out.Values[i] = ec._OrgSubscriptionBulkCreatePayload_orgSubscriptions(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -377494,26 +386821,26 @@ func (ec *executionContext) _OrgMembershipBulkCreatePayload(ctx context.Context, return out } -var orgMembershipConnectionImplementors = []string{"OrgMembershipConnection"} +var orgSubscriptionConnectionImplementors = []string{"OrgSubscriptionConnection"} -func (ec *executionContext) _OrgMembershipConnection(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipConnection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipConnectionImplementors) +func (ec *executionContext) _OrgSubscriptionConnection(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgSubscriptionConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembershipConnection") + out.Values[i] = graphql.MarshalString("OrgSubscriptionConnection") case "edges": - out.Values[i] = ec._OrgMembershipConnection_edges(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionConnection_edges(ctx, field, obj) case "pageInfo": - out.Values[i] = ec._OrgMembershipConnection_pageInfo(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionConnection_pageInfo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "totalCount": - out.Values[i] = ec._OrgMembershipConnection_totalCount(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -377540,19 +386867,19 @@ func (ec *executionContext) _OrgMembershipConnection(ctx context.Context, sel as return out } -var orgMembershipCreatePayloadImplementors = []string{"OrgMembershipCreatePayload"} +var orgSubscriptionCreatePayloadImplementors = []string{"OrgSubscriptionCreatePayload"} -func (ec *executionContext) _OrgMembershipCreatePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgMembershipCreatePayload) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipCreatePayloadImplementors) +func (ec *executionContext) _OrgSubscriptionCreatePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgSubscriptionCreatePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionCreatePayloadImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembershipCreatePayload") - case "orgMembership": - out.Values[i] = ec._OrgMembershipCreatePayload_orgMembership(ctx, field, obj) + out.Values[i] = graphql.MarshalString("OrgSubscriptionCreatePayload") + case "orgSubscription": + out.Values[i] = ec._OrgSubscriptionCreatePayload_orgSubscription(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -377579,19 +386906,19 @@ func (ec *executionContext) _OrgMembershipCreatePayload(ctx context.Context, sel return out } -var orgMembershipDeletePayloadImplementors = []string{"OrgMembershipDeletePayload"} +var orgSubscriptionDeletePayloadImplementors = []string{"OrgSubscriptionDeletePayload"} -func (ec *executionContext) _OrgMembershipDeletePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgMembershipDeletePayload) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipDeletePayloadImplementors) +func (ec *executionContext) _OrgSubscriptionDeletePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgSubscriptionDeletePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionDeletePayloadImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembershipDeletePayload") + out.Values[i] = graphql.MarshalString("OrgSubscriptionDeletePayload") case "deletedID": - out.Values[i] = ec._OrgMembershipDeletePayload_deletedID(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionDeletePayload_deletedID(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -377618,21 +386945,21 @@ func (ec *executionContext) _OrgMembershipDeletePayload(ctx context.Context, sel return out } -var orgMembershipEdgeImplementors = []string{"OrgMembershipEdge"} +var orgSubscriptionEdgeImplementors = []string{"OrgSubscriptionEdge"} -func (ec *executionContext) _OrgMembershipEdge(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipEdge) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipEdgeImplementors) +func (ec *executionContext) _OrgSubscriptionEdge(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgSubscriptionEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionEdgeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembershipEdge") + out.Values[i] = graphql.MarshalString("OrgSubscriptionEdge") case "node": - out.Values[i] = ec._OrgMembershipEdge_node(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionEdge_node(ctx, field, obj) case "cursor": - out.Values[i] = ec._OrgMembershipEdge_cursor(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionEdge_cursor(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -377659,61 +386986,69 @@ func (ec *executionContext) _OrgMembershipEdge(ctx context.Context, sel ast.Sele return out } -var orgMembershipHistoryImplementors = []string{"OrgMembershipHistory", "Node"} +var orgSubscriptionHistoryImplementors = []string{"OrgSubscriptionHistory", "Node"} -func (ec *executionContext) _OrgMembershipHistory(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipHistory) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipHistoryImplementors) +func (ec *executionContext) _OrgSubscriptionHistory(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgSubscriptionHistory) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionHistoryImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembershipHistory") + out.Values[i] = graphql.MarshalString("OrgSubscriptionHistory") case "id": - out.Values[i] = ec._OrgMembershipHistory_id(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_id(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "historyTime": - out.Values[i] = ec._OrgMembershipHistory_historyTime(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_historyTime(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "ref": - out.Values[i] = ec._OrgMembershipHistory_ref(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_ref(ctx, field, obj) case "operation": - out.Values[i] = ec._OrgMembershipHistory_operation(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_operation(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "createdAt": - out.Values[i] = ec._OrgMembershipHistory_createdAt(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_createdAt(ctx, field, obj) case "updatedAt": - out.Values[i] = ec._OrgMembershipHistory_updatedAt(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_updatedAt(ctx, field, obj) case "createdBy": - out.Values[i] = ec._OrgMembershipHistory_createdBy(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_createdBy(ctx, field, obj) case "updatedBy": - out.Values[i] = ec._OrgMembershipHistory_updatedBy(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_updatedBy(ctx, field, obj) + case "tags": + out.Values[i] = ec._OrgSubscriptionHistory_tags(ctx, field, obj) case "deletedAt": - out.Values[i] = ec._OrgMembershipHistory_deletedAt(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_deletedAt(ctx, field, obj) case "deletedBy": - out.Values[i] = ec._OrgMembershipHistory_deletedBy(ctx, field, obj) - case "role": - out.Values[i] = ec._OrgMembershipHistory_role(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "organizationID": - out.Values[i] = ec._OrgMembershipHistory_organizationID(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "userID": - out.Values[i] = ec._OrgMembershipHistory_userID(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistory_deletedBy(ctx, field, obj) + case "ownerID": + out.Values[i] = ec._OrgSubscriptionHistory_ownerID(ctx, field, obj) + case "stripeSubscriptionID": + out.Values[i] = ec._OrgSubscriptionHistory_stripeSubscriptionID(ctx, field, obj) + case "productTier": + out.Values[i] = ec._OrgSubscriptionHistory_productTier(ctx, field, obj) + case "stripeProductTierID": + out.Values[i] = ec._OrgSubscriptionHistory_stripeProductTierID(ctx, field, obj) + case "stripeSubscriptionStatus": + out.Values[i] = ec._OrgSubscriptionHistory_stripeSubscriptionStatus(ctx, field, obj) + case "active": + out.Values[i] = ec._OrgSubscriptionHistory_active(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } + case "stripeCustomerID": + out.Values[i] = ec._OrgSubscriptionHistory_stripeCustomerID(ctx, field, obj) + case "expiresAt": + out.Values[i] = ec._OrgSubscriptionHistory_expiresAt(ctx, field, obj) + case "features": + out.Values[i] = ec._OrgSubscriptionHistory_features(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -377737,26 +387072,26 @@ func (ec *executionContext) _OrgMembershipHistory(ctx context.Context, sel ast.S return out } -var orgMembershipHistoryConnectionImplementors = []string{"OrgMembershipHistoryConnection"} +var orgSubscriptionHistoryConnectionImplementors = []string{"OrgSubscriptionHistoryConnection"} -func (ec *executionContext) _OrgMembershipHistoryConnection(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipHistoryConnection) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipHistoryConnectionImplementors) +func (ec *executionContext) _OrgSubscriptionHistoryConnection(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgSubscriptionHistoryConnection) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionHistoryConnectionImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembershipHistoryConnection") + out.Values[i] = graphql.MarshalString("OrgSubscriptionHistoryConnection") case "edges": - out.Values[i] = ec._OrgMembershipHistoryConnection_edges(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistoryConnection_edges(ctx, field, obj) case "pageInfo": - out.Values[i] = ec._OrgMembershipHistoryConnection_pageInfo(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistoryConnection_pageInfo(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "totalCount": - out.Values[i] = ec._OrgMembershipHistoryConnection_totalCount(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistoryConnection_totalCount(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -377783,21 +387118,21 @@ func (ec *executionContext) _OrgMembershipHistoryConnection(ctx context.Context, return out } -var orgMembershipHistoryEdgeImplementors = []string{"OrgMembershipHistoryEdge"} +var orgSubscriptionHistoryEdgeImplementors = []string{"OrgSubscriptionHistoryEdge"} -func (ec *executionContext) _OrgMembershipHistoryEdge(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgMembershipHistoryEdge) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipHistoryEdgeImplementors) +func (ec *executionContext) _OrgSubscriptionHistoryEdge(ctx context.Context, sel ast.SelectionSet, obj *generated.OrgSubscriptionHistoryEdge) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionHistoryEdgeImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembershipHistoryEdge") + out.Values[i] = graphql.MarshalString("OrgSubscriptionHistoryEdge") case "node": - out.Values[i] = ec._OrgMembershipHistoryEdge_node(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistoryEdge_node(ctx, field, obj) case "cursor": - out.Values[i] = ec._OrgMembershipHistoryEdge_cursor(ctx, field, obj) + out.Values[i] = ec._OrgSubscriptionHistoryEdge_cursor(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -377824,19 +387159,55 @@ func (ec *executionContext) _OrgMembershipHistoryEdge(ctx context.Context, sel a return out } -var orgMembershipUpdatePayloadImplementors = []string{"OrgMembershipUpdatePayload"} +var orgSubscriptionSearchResultImplementors = []string{"OrgSubscriptionSearchResult", "SearchResult"} -func (ec *executionContext) _OrgMembershipUpdatePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgMembershipUpdatePayload) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, orgMembershipUpdatePayloadImplementors) +func (ec *executionContext) _OrgSubscriptionSearchResult(ctx context.Context, sel ast.SelectionSet, obj *OrgSubscriptionSearchResult) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionSearchResultImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("OrgMembershipUpdatePayload") - case "orgMembership": - out.Values[i] = ec._OrgMembershipUpdatePayload_orgMembership(ctx, field, obj) + out.Values[i] = graphql.MarshalString("OrgSubscriptionSearchResult") + case "orgSubscriptions": + out.Values[i] = ec._OrgSubscriptionSearchResult_orgSubscriptions(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var orgSubscriptionUpdatePayloadImplementors = []string{"OrgSubscriptionUpdatePayload"} + +func (ec *executionContext) _OrgSubscriptionUpdatePayload(ctx context.Context, sel ast.SelectionSet, obj *OrgSubscriptionUpdatePayload) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, orgSubscriptionUpdatePayloadImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("OrgSubscriptionUpdatePayload") + case "orgSubscription": + out.Values[i] = ec._OrgSubscriptionUpdatePayload_orgSubscription(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -378079,7 +387450,40 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "procedureCreators": + case "procedureCreators": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Organization_procedureCreators(ctx, field, obj) + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "programCreators": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378088,7 +387492,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_procedureCreators(ctx, field, obj) + res = ec._Organization_programCreators(ctx, field, obj) return res } @@ -378112,7 +387516,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "programCreators": + case "riskCreators": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378121,7 +387525,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_programCreators(ctx, field, obj) + res = ec._Organization_riskCreators(ctx, field, obj) return res } @@ -378145,7 +387549,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "riskCreators": + case "templateCreators": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378154,7 +387558,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_riskCreators(ctx, field, obj) + res = ec._Organization_templateCreators(ctx, field, obj) return res } @@ -378178,7 +387582,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "templateCreators": + case "parent": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378187,7 +387591,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_templateCreators(ctx, field, obj) + res = ec._Organization_parent(ctx, field, obj) return res } @@ -378211,16 +387615,19 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "parent": + case "children": field := field - innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { defer func() { if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_parent(ctx, field, obj) + res = ec._Organization_children(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } return res } @@ -378244,19 +387651,16 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "children": + case "groups": field := field - innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { defer func() { if r := recover(); r != nil { ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_children(ctx, field, obj) - if res == graphql.Null { - atomic.AddUint32(&fs.Invalids, 1) - } + res = ec._Organization_groups(ctx, field, obj) return res } @@ -378280,7 +387684,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "groups": + case "templates": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378289,7 +387693,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_groups(ctx, field, obj) + res = ec._Organization_templates(ctx, field, obj) return res } @@ -378313,7 +387717,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "templates": + case "integrations": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378322,7 +387726,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_templates(ctx, field, obj) + res = ec._Organization_integrations(ctx, field, obj) return res } @@ -378346,7 +387750,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "integrations": + case "setting": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378355,7 +387759,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_integrations(ctx, field, obj) + res = ec._Organization_setting(ctx, field, obj) return res } @@ -378379,7 +387783,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "setting": + case "documentdata": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378388,7 +387792,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_setting(ctx, field, obj) + res = ec._Organization_documentdata(ctx, field, obj) return res } @@ -378412,7 +387816,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "documentdata": + case "entitlements": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378421,7 +387825,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_documentdata(ctx, field, obj) + res = ec._Organization_entitlements(ctx, field, obj) return res } @@ -378445,7 +387849,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection } out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "entitlements": + case "orgsubscriptions": field := field innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { @@ -378454,7 +387858,7 @@ func (ec *executionContext) _Organization(ctx context.Context, sel ast.Selection ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Organization_entitlements(ctx, field, obj) + res = ec._Organization_orgsubscriptions(ctx, field, obj) return res } @@ -384599,6 +394003,50 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "orgSubscriptions": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_orgSubscriptions(ctx, field) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "orgSubscriptionHistories": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_orgSubscriptionHistories(ctx, field) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) case "organizations": field := field @@ -385658,6 +395106,25 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "adminOrgSubscriptionSearch": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_adminOrgSubscriptionSearch(ctx, field) + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) case "adminOrganizationSearch": field := field @@ -386537,6 +396004,28 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "orgSubscription": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_orgSubscription(ctx, field) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) case "personalAccessToken": field := field @@ -387046,6 +396535,25 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "orgSubscriptionSearch": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_orgSubscriptionSearch(ctx, field) + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) case "organizationSearch": field := field @@ -395632,6 +405140,16 @@ func (ec *executionContext) unmarshalNCreateOrgMembershipInput2ᚖgithubᚗcom return &res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) unmarshalNCreateOrgSubscriptionInput2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐCreateOrgSubscriptionInput(ctx context.Context, v interface{}) (generated.CreateOrgSubscriptionInput, error) { + res, err := ec.unmarshalInputCreateOrgSubscriptionInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) unmarshalNCreateOrgSubscriptionInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐCreateOrgSubscriptionInput(ctx context.Context, v interface{}) (*generated.CreateOrgSubscriptionInput, error) { + res, err := ec.unmarshalInputCreateOrgSubscriptionInput(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + func (ec *executionContext) unmarshalNCreateOrganizationInput2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐCreateOrganizationInput(ctx context.Context, v interface{}) (generated.CreateOrganizationInput, error) { res, err := ec.unmarshalInputCreateOrganizationInput(ctx, v) return res, graphql.ErrorOnPath(ctx, err) @@ -398516,6 +408034,124 @@ func (ec *executionContext) unmarshalNOrgMembershipWhereInput2ᚖgithubᚗcomᚋ return &res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) marshalNOrgSubscription2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscription(ctx context.Context, sel ast.SelectionSet, v generated.OrgSubscription) graphql.Marshaler { + return ec._OrgSubscription(ctx, sel, &v) +} + +func (ec *executionContext) marshalNOrgSubscription2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscription(ctx context.Context, sel ast.SelectionSet, v *generated.OrgSubscription) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._OrgSubscription(ctx, sel, v) +} + +func (ec *executionContext) marshalNOrgSubscriptionBulkCreatePayload2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionBulkCreatePayload(ctx context.Context, sel ast.SelectionSet, v OrgSubscriptionBulkCreatePayload) graphql.Marshaler { + return ec._OrgSubscriptionBulkCreatePayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNOrgSubscriptionBulkCreatePayload2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionBulkCreatePayload(ctx context.Context, sel ast.SelectionSet, v *OrgSubscriptionBulkCreatePayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._OrgSubscriptionBulkCreatePayload(ctx, sel, v) +} + +func (ec *executionContext) marshalNOrgSubscriptionConnection2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionConnection(ctx context.Context, sel ast.SelectionSet, v generated.OrgSubscriptionConnection) graphql.Marshaler { + return ec._OrgSubscriptionConnection(ctx, sel, &v) +} + +func (ec *executionContext) marshalNOrgSubscriptionConnection2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionConnection(ctx context.Context, sel ast.SelectionSet, v *generated.OrgSubscriptionConnection) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._OrgSubscriptionConnection(ctx, sel, v) +} + +func (ec *executionContext) marshalNOrgSubscriptionCreatePayload2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionCreatePayload(ctx context.Context, sel ast.SelectionSet, v OrgSubscriptionCreatePayload) graphql.Marshaler { + return ec._OrgSubscriptionCreatePayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNOrgSubscriptionCreatePayload2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionCreatePayload(ctx context.Context, sel ast.SelectionSet, v *OrgSubscriptionCreatePayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._OrgSubscriptionCreatePayload(ctx, sel, v) +} + +func (ec *executionContext) marshalNOrgSubscriptionDeletePayload2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionDeletePayload(ctx context.Context, sel ast.SelectionSet, v OrgSubscriptionDeletePayload) graphql.Marshaler { + return ec._OrgSubscriptionDeletePayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNOrgSubscriptionDeletePayload2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionDeletePayload(ctx context.Context, sel ast.SelectionSet, v *OrgSubscriptionDeletePayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._OrgSubscriptionDeletePayload(ctx, sel, v) +} + +func (ec *executionContext) marshalNOrgSubscriptionHistoryConnection2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryConnection(ctx context.Context, sel ast.SelectionSet, v generated.OrgSubscriptionHistoryConnection) graphql.Marshaler { + return ec._OrgSubscriptionHistoryConnection(ctx, sel, &v) +} + +func (ec *executionContext) marshalNOrgSubscriptionHistoryConnection2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryConnection(ctx context.Context, sel ast.SelectionSet, v *generated.OrgSubscriptionHistoryConnection) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._OrgSubscriptionHistoryConnection(ctx, sel, v) +} + +func (ec *executionContext) unmarshalNOrgSubscriptionHistoryOpType2githubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx context.Context, v interface{}) (history.OpType, error) { + var res history.OpType + err := res.UnmarshalGQL(v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalNOrgSubscriptionHistoryOpType2githubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx context.Context, sel ast.SelectionSet, v history.OpType) graphql.Marshaler { + return v +} + +func (ec *executionContext) unmarshalNOrgSubscriptionHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryWhereInput(ctx context.Context, v interface{}) (*generated.OrgSubscriptionHistoryWhereInput, error) { + res, err := ec.unmarshalInputOrgSubscriptionHistoryWhereInput(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalNOrgSubscriptionUpdatePayload2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionUpdatePayload(ctx context.Context, sel ast.SelectionSet, v OrgSubscriptionUpdatePayload) graphql.Marshaler { + return ec._OrgSubscriptionUpdatePayload(ctx, sel, &v) +} + +func (ec *executionContext) marshalNOrgSubscriptionUpdatePayload2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionUpdatePayload(ctx context.Context, sel ast.SelectionSet, v *OrgSubscriptionUpdatePayload) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._OrgSubscriptionUpdatePayload(ctx, sel, v) +} + +func (ec *executionContext) unmarshalNOrgSubscriptionWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionWhereInput(ctx context.Context, v interface{}) (*generated.OrgSubscriptionWhereInput, error) { + res, err := ec.unmarshalInputOrgSubscriptionWhereInput(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + func (ec *executionContext) marshalNOrganization2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganization(ctx context.Context, sel ast.SelectionSet, v generated.Organization) graphql.Marshaler { return ec._Organization(ctx, sel, &v) } @@ -400367,6 +410003,11 @@ func (ec *executionContext) unmarshalNUpdateOrgMembershipInput2githubᚗcomᚋth return res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) unmarshalNUpdateOrgSubscriptionInput2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUpdateOrgSubscriptionInput(ctx context.Context, v interface{}) (generated.UpdateOrgSubscriptionInput, error) { + res, err := ec.unmarshalInputUpdateOrgSubscriptionInput(ctx, v) + return res, graphql.ErrorOnPath(ctx, err) +} + func (ec *executionContext) unmarshalNUpdateOrganizationInput2githubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐUpdateOrganizationInput(ctx context.Context, v interface{}) (generated.UpdateOrganizationInput, error) { res, err := ec.unmarshalInputUpdateOrganizationInput(ctx, v) return res, graphql.ErrorOnPath(ctx, err) @@ -403313,6 +412954,26 @@ func (ec *executionContext) unmarshalOCreateOrgMembershipInput2ᚕᚖgithubᚗco return res, nil } +func (ec *executionContext) unmarshalOCreateOrgSubscriptionInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐCreateOrgSubscriptionInputᚄ(ctx context.Context, v interface{}) ([]*generated.CreateOrgSubscriptionInput, error) { + if v == nil { + return nil, nil + } + var vSlice []interface{} + if v != nil { + vSlice = graphql.CoerceList(v) + } + var err error + res := make([]*generated.CreateOrgSubscriptionInput, len(vSlice)) + for i := range vSlice { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) + res[i], err = ec.unmarshalNCreateOrgSubscriptionInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐCreateOrgSubscriptionInput(ctx, vSlice[i]) + if err != nil { + return nil, err + } + } + return res, nil +} + func (ec *executionContext) unmarshalOCreateOrganizationInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐCreateOrganizationInputᚄ(ctx context.Context, v interface{}) ([]*generated.CreateOrganizationInput, error) { if v == nil { return nil, nil @@ -410754,6 +420415,309 @@ func (ec *executionContext) unmarshalOOrgMembershipWhereInput2ᚖgithubᚗcomᚋ return &res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) marshalOOrgSubscription2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionᚄ(ctx context.Context, sel ast.SelectionSet, v []*generated.OrgSubscription) graphql.Marshaler { + if v == nil { + return graphql.Null + } + ret := make(graphql.Array, len(v)) + var wg sync.WaitGroup + isLen1 := len(v) == 1 + if !isLen1 { + wg.Add(len(v)) + } + for i := range v { + i := i + fc := &graphql.FieldContext{ + Index: &i, + Result: &v[i], + } + ctx := graphql.WithFieldContext(ctx, fc) + f := func(i int) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = nil + } + }() + if !isLen1 { + defer wg.Done() + } + ret[i] = ec.marshalNOrgSubscription2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscription(ctx, sel, v[i]) + } + if isLen1 { + f(i) + } else { + go f(i) + } + + } + wg.Wait() + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalOOrgSubscription2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscription(ctx context.Context, sel ast.SelectionSet, v *generated.OrgSubscription) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._OrgSubscription(ctx, sel, v) +} + +func (ec *executionContext) marshalOOrgSubscriptionEdge2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionEdge(ctx context.Context, sel ast.SelectionSet, v []*generated.OrgSubscriptionEdge) graphql.Marshaler { + if v == nil { + return graphql.Null + } + ret := make(graphql.Array, len(v)) + var wg sync.WaitGroup + isLen1 := len(v) == 1 + if !isLen1 { + wg.Add(len(v)) + } + for i := range v { + i := i + fc := &graphql.FieldContext{ + Index: &i, + Result: &v[i], + } + ctx := graphql.WithFieldContext(ctx, fc) + f := func(i int) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = nil + } + }() + if !isLen1 { + defer wg.Done() + } + ret[i] = ec.marshalOOrgSubscriptionEdge2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionEdge(ctx, sel, v[i]) + } + if isLen1 { + f(i) + } else { + go f(i) + } + + } + wg.Wait() + + return ret +} + +func (ec *executionContext) marshalOOrgSubscriptionEdge2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionEdge(ctx context.Context, sel ast.SelectionSet, v *generated.OrgSubscriptionEdge) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._OrgSubscriptionEdge(ctx, sel, v) +} + +func (ec *executionContext) marshalOOrgSubscriptionHistory2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistory(ctx context.Context, sel ast.SelectionSet, v *generated.OrgSubscriptionHistory) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._OrgSubscriptionHistory(ctx, sel, v) +} + +func (ec *executionContext) marshalOOrgSubscriptionHistoryEdge2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryEdge(ctx context.Context, sel ast.SelectionSet, v []*generated.OrgSubscriptionHistoryEdge) graphql.Marshaler { + if v == nil { + return graphql.Null + } + ret := make(graphql.Array, len(v)) + var wg sync.WaitGroup + isLen1 := len(v) == 1 + if !isLen1 { + wg.Add(len(v)) + } + for i := range v { + i := i + fc := &graphql.FieldContext{ + Index: &i, + Result: &v[i], + } + ctx := graphql.WithFieldContext(ctx, fc) + f := func(i int) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = nil + } + }() + if !isLen1 { + defer wg.Done() + } + ret[i] = ec.marshalOOrgSubscriptionHistoryEdge2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryEdge(ctx, sel, v[i]) + } + if isLen1 { + f(i) + } else { + go f(i) + } + + } + wg.Wait() + + return ret +} + +func (ec *executionContext) marshalOOrgSubscriptionHistoryEdge2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryEdge(ctx context.Context, sel ast.SelectionSet, v *generated.OrgSubscriptionHistoryEdge) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._OrgSubscriptionHistoryEdge(ctx, sel, v) +} + +func (ec *executionContext) unmarshalOOrgSubscriptionHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx context.Context, v interface{}) ([]history.OpType, error) { + if v == nil { + return nil, nil + } + var vSlice []interface{} + if v != nil { + vSlice = graphql.CoerceList(v) + } + var err error + res := make([]history.OpType, len(vSlice)) + for i := range vSlice { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) + res[i], err = ec.unmarshalNOrgSubscriptionHistoryOpType2githubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, vSlice[i]) + if err != nil { + return nil, err + } + } + return res, nil +} + +func (ec *executionContext) marshalOOrgSubscriptionHistoryOpType2ᚕgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []history.OpType) graphql.Marshaler { + if v == nil { + return graphql.Null + } + ret := make(graphql.Array, len(v)) + var wg sync.WaitGroup + isLen1 := len(v) == 1 + if !isLen1 { + wg.Add(len(v)) + } + for i := range v { + i := i + fc := &graphql.FieldContext{ + Index: &i, + Result: &v[i], + } + ctx := graphql.WithFieldContext(ctx, fc) + f := func(i int) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = nil + } + }() + if !isLen1 { + defer wg.Done() + } + ret[i] = ec.marshalNOrgSubscriptionHistoryOpType2githubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx, sel, v[i]) + } + if isLen1 { + f(i) + } else { + go f(i) + } + + } + wg.Wait() + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) unmarshalOOrgSubscriptionHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx context.Context, v interface{}) (*history.OpType, error) { + if v == nil { + return nil, nil + } + var res = new(history.OpType) + err := res.UnmarshalGQL(v) + return res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalOOrgSubscriptionHistoryOpType2ᚖgithubᚗcomᚋtheopenlaneᚋentxᚋhistoryᚐOpType(ctx context.Context, sel ast.SelectionSet, v *history.OpType) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return v +} + +func (ec *executionContext) unmarshalOOrgSubscriptionHistoryWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryWhereInputᚄ(ctx context.Context, v interface{}) ([]*generated.OrgSubscriptionHistoryWhereInput, error) { + if v == nil { + return nil, nil + } + var vSlice []interface{} + if v != nil { + vSlice = graphql.CoerceList(v) + } + var err error + res := make([]*generated.OrgSubscriptionHistoryWhereInput, len(vSlice)) + for i := range vSlice { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) + res[i], err = ec.unmarshalNOrgSubscriptionHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryWhereInput(ctx, vSlice[i]) + if err != nil { + return nil, err + } + } + return res, nil +} + +func (ec *executionContext) unmarshalOOrgSubscriptionHistoryWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionHistoryWhereInput(ctx context.Context, v interface{}) (*generated.OrgSubscriptionHistoryWhereInput, error) { + if v == nil { + return nil, nil + } + res, err := ec.unmarshalInputOrgSubscriptionHistoryWhereInput(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) marshalOOrgSubscriptionSearchResult2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋgraphapiᚐOrgSubscriptionSearchResult(ctx context.Context, sel ast.SelectionSet, v *OrgSubscriptionSearchResult) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._OrgSubscriptionSearchResult(ctx, sel, v) +} + +func (ec *executionContext) unmarshalOOrgSubscriptionWhereInput2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionWhereInputᚄ(ctx context.Context, v interface{}) ([]*generated.OrgSubscriptionWhereInput, error) { + if v == nil { + return nil, nil + } + var vSlice []interface{} + if v != nil { + vSlice = graphql.CoerceList(v) + } + var err error + res := make([]*generated.OrgSubscriptionWhereInput, len(vSlice)) + for i := range vSlice { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) + res[i], err = ec.unmarshalNOrgSubscriptionWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionWhereInput(ctx, vSlice[i]) + if err != nil { + return nil, err + } + } + return res, nil +} + +func (ec *executionContext) unmarshalOOrgSubscriptionWhereInput2ᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrgSubscriptionWhereInput(ctx context.Context, v interface{}) (*generated.OrgSubscriptionWhereInput, error) { + if v == nil { + return nil, nil + } + res, err := ec.unmarshalInputOrgSubscriptionWhereInput(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + func (ec *executionContext) marshalOOrganization2ᚕᚖgithubᚗcomᚋtheopenlaneᚋcoreᚋinternalᚋentᚋgeneratedᚐOrganizationᚄ(ctx context.Context, sel ast.SelectionSet, v []*generated.Organization) graphql.Marshaler { if v == nil { return graphql.Null diff --git a/internal/graphapi/orgsubscription.resolvers.go b/internal/graphapi/orgsubscription.resolvers.go new file mode 100644 index 00000000..594e2ed6 --- /dev/null +++ b/internal/graphapi/orgsubscription.resolvers.go @@ -0,0 +1,101 @@ +package graphapi + +// This file will be automatically regenerated based on the schema, any resolver implementations +// will be copied through when generating and any unknown code will be moved to the end. +// Code generated by github.com/99designs/gqlgen + +import ( + "context" + + "github.com/99designs/gqlgen/graphql" + "github.com/rs/zerolog/log" + "github.com/theopenlane/core/internal/ent/generated" + "github.com/theopenlane/utils/rout" +) + +// CreateOrgSubscription is the resolver for the createOrgSubscription field. +func (r *mutationResolver) CreateOrgSubscription(ctx context.Context, input generated.CreateOrgSubscriptionInput) (*OrgSubscriptionCreatePayload, error) { + // set the organization in the auth context if its not done for us + if err := setOrganizationInAuthContext(ctx, input.OwnerID); err != nil { + log.Error().Err(err).Msg("failed to set organization in auth context") + + return nil, rout.NewMissingRequiredFieldError("owner_id") + } + + res, err := withTransactionalMutation(ctx).OrgSubscription.Create().SetInput(input).Save(ctx) + if err != nil { + return nil, parseRequestError(err, action{action: ActionCreate, object: "orgsubscription"}) + } + + return &OrgSubscriptionCreatePayload{ + OrgSubscription: res, + }, nil +} + +// CreateBulkOrgSubscription is the resolver for the createBulkOrgSubscription field. +func (r *mutationResolver) CreateBulkOrgSubscription(ctx context.Context, input []*generated.CreateOrgSubscriptionInput) (*OrgSubscriptionBulkCreatePayload, error) { + return r.bulkCreateOrgSubscription(ctx, input) +} + +// CreateBulkCSVOrgSubscription is the resolver for the createBulkCSVOrgSubscription field. +func (r *mutationResolver) CreateBulkCSVOrgSubscription(ctx context.Context, input graphql.Upload) (*OrgSubscriptionBulkCreatePayload, error) { + data, err := unmarshalBulkData[generated.CreateOrgSubscriptionInput](input) + if err != nil { + log.Error().Err(err).Msg("failed to unmarshal bulk data") + + return nil, err + } + + return r.bulkCreateOrgSubscription(ctx, data) +} + +// UpdateOrgSubscription is the resolver for the updateOrgSubscription field. +func (r *mutationResolver) UpdateOrgSubscription(ctx context.Context, id string, input generated.UpdateOrgSubscriptionInput) (*OrgSubscriptionUpdatePayload, error) { + res, err := withTransactionalMutation(ctx).OrgSubscription.Get(ctx, id) + if err != nil { + return nil, parseRequestError(err, action{action: ActionUpdate, object: "orgsubscription"}) + } + // set the organization in the auth context if its not done for us + if err := setOrganizationInAuthContext(ctx, &res.OwnerID); err != nil { + log.Error().Err(err).Msg("failed to set organization in auth context") + + return nil, rout.ErrPermissionDenied + } + + // setup update request + req := res.Update().SetInput(input).AppendTags(input.AppendTags).AppendFeatures(input.AppendFeatures) + + res, err = req.Save(ctx) + if err != nil { + return nil, parseRequestError(err, action{action: ActionUpdate, object: "orgsubscription"}) + } + + return &OrgSubscriptionUpdatePayload{ + OrgSubscription: res, + }, nil +} + +// DeleteOrgSubscription is the resolver for the deleteOrgSubscription field. +func (r *mutationResolver) DeleteOrgSubscription(ctx context.Context, id string) (*OrgSubscriptionDeletePayload, error) { + if err := withTransactionalMutation(ctx).OrgSubscription.DeleteOneID(id).Exec(ctx); err != nil { + return nil, parseRequestError(err, action{action: ActionDelete, object: "orgsubscription"}) + } + + if err := generated.OrgSubscriptionEdgeCleanup(ctx, id); err != nil { + return nil, newCascadeDeleteError(err) + } + + return &OrgSubscriptionDeletePayload{ + DeletedID: id, + }, nil +} + +// OrgSubscription is the resolver for the orgSubscription field. +func (r *queryResolver) OrgSubscription(ctx context.Context, id string) (*generated.OrgSubscription, error) { + res, err := withTransactionalMutation(ctx).OrgSubscription.Get(ctx, id) + if err != nil { + return nil, parseRequestError(err, action{action: ActionGet, object: "orgsubscription"}) + } + + return res, nil +} diff --git a/internal/graphapi/search.go b/internal/graphapi/search.go index 2f45dc19..1f54a575 100644 --- a/internal/graphapi/search.go +++ b/internal/graphapi/search.go @@ -32,6 +32,7 @@ import ( "github.com/theopenlane/core/internal/ent/generated/ohauthtootoken" "github.com/theopenlane/core/internal/ent/generated/organization" "github.com/theopenlane/core/internal/ent/generated/organizationsetting" + "github.com/theopenlane/core/internal/ent/generated/orgsubscription" "github.com/theopenlane/core/internal/ent/generated/personalaccesstoken" "github.com/theopenlane/core/internal/ent/generated/procedure" "github.com/theopenlane/core/internal/ent/generated/program" @@ -806,6 +807,43 @@ func adminSearchOhAuthTooTokens(ctx context.Context, query string) ([]*generated ).All(ctx) } +// searchOrgSubscription searches for OrgSubscription based on the query string looking for matches +func searchOrgSubscriptions(ctx context.Context, query string) ([]*generated.OrgSubscription, error) { + return withTransactionalMutation(ctx).OrgSubscription.Query().Where( + orgsubscription.Or( + orgsubscription.IDContainsFold(query), // search by ID + func(s *sql.Selector) { + likeQuery := "%" + query + "%" + s.Where(sql.ExprP("(tags)::text LIKE $2", likeQuery)) // search by Tags + }, + ), + ).All(ctx) +} + +// searchOrgSubscription searches for OrgSubscription based on the query string looking for matches +func adminSearchOrgSubscriptions(ctx context.Context, query string) ([]*generated.OrgSubscription, error) { + return withTransactionalMutation(ctx).OrgSubscription.Query().Where( + orgsubscription.Or( + orgsubscription.IDContainsFold(query), // search by ID + func(s *sql.Selector) { + likeQuery := "%" + query + "%" + s.Where(sql.ExprP("(tags)::text LIKE $2", likeQuery)) // search by Tags + }, + orgsubscription.DeletedByContainsFold(query), // search by DeletedBy + orgsubscription.OwnerIDContainsFold(query), // search by OwnerID + orgsubscription.StripeSubscriptionIDContainsFold(query), // search by StripeSubscriptionID + orgsubscription.ProductTierContainsFold(query), // search by ProductTier + orgsubscription.StripeProductTierIDContainsFold(query), // search by StripeProductTierID + orgsubscription.StripeSubscriptionStatusContainsFold(query), // search by StripeSubscriptionStatus + orgsubscription.StripeCustomerIDContainsFold(query), // search by StripeCustomerID + func(s *sql.Selector) { + likeQuery := "%" + query + "%" + s.Where(sql.ExprP("(features)::text LIKE $10", likeQuery)) // search by Features + }, + ), + ).All(ctx) +} + // searchOrganization searches for Organization based on the query string looking for matches func searchOrganizations(ctx context.Context, query string) ([]*generated.Organization, error) { return withTransactionalMutation(ctx).Organization.Query().Where( diff --git a/internal/graphapi/search.resolvers.go b/internal/graphapi/search.resolvers.go index 2c72dfc3..4a222469 100644 --- a/internal/graphapi/search.resolvers.go +++ b/internal/graphapi/search.resolvers.go @@ -38,6 +38,7 @@ func (r *queryResolver) Search(ctx context.Context, query string) (*SearchResult narrativeResults []*generated.Narrative oauthproviderResults []*generated.OauthProvider ohauthtootokenResults []*generated.OhAuthTooToken + orgsubscriptionResults []*generated.OrgSubscription organizationResults []*generated.Organization organizationsettingResults []*generated.OrganizationSetting personalaccesstokenResults []*generated.PersonalAccessToken @@ -203,6 +204,13 @@ func (r *queryResolver) Search(ctx context.Context, query string) (*SearchResult errors = append(errors, err) } }, + func() { + var err error + orgsubscriptionResults, err = searchOrgSubscriptions(ctx, query) + if err != nil { + errors = append(errors, err) + } + }, func() { var err error organizationResults, err = searchOrganizations(ctx, query) @@ -383,6 +391,9 @@ func (r *queryResolver) Search(ctx context.Context, query string) (*SearchResult OhAuthTooTokenSearchResult{ OhAuthTooTokens: ohauthtootokenResults, }, + OrgSubscriptionSearchResult{ + OrgSubscriptions: orgsubscriptionResults, + }, OrganizationSearchResult{ Organizations: organizationResults, }, @@ -683,6 +694,18 @@ func (r *queryResolver) OhAuthTooTokenSearch(ctx context.Context, query string) OhAuthTooTokens: ohauthtootokenResults, }, nil } +func (r *queryResolver) OrgSubscriptionSearch(ctx context.Context, query string) (*OrgSubscriptionSearchResult, error) { + orgsubscriptionResults, err := searchOrgSubscriptions(ctx, query) + + if err != nil { + return nil, ErrSearchFailed + } + + // return the results + return &OrgSubscriptionSearchResult{ + OrgSubscriptions: orgsubscriptionResults, + }, nil +} func (r *queryResolver) OrganizationSearch(ctx context.Context, query string) (*OrganizationSearchResult, error) { organizationResults, err := searchOrganizations(ctx, query) diff --git a/internal/httpserve/handlers/checkout.go b/internal/httpserve/handlers/checkout.go deleted file mode 100644 index b29d1934..00000000 --- a/internal/httpserve/handlers/checkout.go +++ /dev/null @@ -1,114 +0,0 @@ -package handlers - -import ( - "context" - - "github.com/rs/zerolog/log" - "github.com/stripe/stripe-go/v81" - echo "github.com/theopenlane/echox" - - "github.com/theopenlane/iam/auth" - - ent "github.com/theopenlane/core/internal/ent/generated" - "github.com/theopenlane/core/pkg/models" -) - -// CheckoutSessionHandler is responsible for handling requests to /checkout/session and creating a stripe checkout session based on the user's organization context -func (h *Handler) CheckoutSessionHandler(ctx echo.Context) error { - reqCtx := ctx.Request().Context() - - orgID, err := auth.GetOrganizationIDFromContext(reqCtx) - if err != nil { - log.Error().Err(err).Msg("unable to get organization id from context") - - return h.BadRequest(ctx, err) - } - - settings, err := h.getOrgSettingByOrgID(reqCtx, orgID) - if err != nil { - log.Error().Err(err).Str("organization_id", orgID).Msg("unable to get organization settings by org id") - - return h.BadRequest(ctx, err) - } - - cust, err := h.fetchOrCreateStripe(reqCtx, settings) - if err != nil { - log.Error().Err(err).Msg("unable to fetch or create stripe customer") - - return h.BadRequest(ctx, err) - } - - // TODO: determine if customerSession + pricing table is what we want, or if the billingportalsession is the correct URL to return and then redirect the customer - params := &stripe.CustomerSessionParams{ - Customer: stripe.String(cust.ID), - Components: &stripe.CustomerSessionComponentsParams{ - PricingTable: &stripe.CustomerSessionComponentsPricingTableParams{ - Enabled: stripe.Bool(true), - }, - }, - } - - result, err := h.Entitlements.Client.CustomerSessions.New(params) - if err != nil { - log.Error().Err(err).Msg("unable to create stripe checkout session") - - return h.BadRequest(ctx, err) - } - - // set the out attributes we send back to the client only on success - out := &models.EntitlementsReply{ - ClientSecret: result.ClientSecret, - } - - return h.Success(ctx, out) -} - -// CheckoutSuccessHandler is responsible for handling requests to the `/checkout/success` endpoint -func (h *Handler) CheckoutSuccessHandler(ctx echo.Context) error { - // TODO[MKA] Determine what is needed of the success handler and implement - return h.Success(ctx, nil) -} - -func (h *Handler) fetchOrCreateStripe(context context.Context, orgsetting *ent.OrganizationSetting) (*stripe.Customer, error) { - if orgsetting.BillingEmail == "" { - log.Error().Msgf("billing email is required to be set to create a checkout session") - return nil, ErrNoBillingEmail - } - - if orgsetting.StripeID != "" { - cust, err := h.Entitlements.Client.Customers.Get(orgsetting.StripeID, nil) - if err != nil { - log.Error().Err(err).Msg("error fetching stripe customer") - return nil, err - } - - if cust.Email != orgsetting.BillingEmail { - log.Error().Msgf("customer email does not match, updating stripe customer") - - _, err := h.Entitlements.Client.Customers.Update(orgsetting.StripeID, &stripe.CustomerParams{ - Email: &orgsetting.BillingEmail, - }) - if err != nil { - log.Error().Err(err).Msg("error updating stripe customer") - return nil, err - } - } - - return cust, nil - } - - stripeCustomer, err := h.Entitlements.Client.Customers.New(&stripe.CustomerParams{ - Email: &orgsetting.BillingEmail, - }) - if err != nil { - log.Error().Err(err).Msg("error creating stripe customer") - return nil, err - } - - if err := h.updateOrganizationSettingWithCustomerID(context, orgsetting.ID, stripeCustomer.ID); err != nil { - log.Error().Err(err).Msg("error updating organization setting with stripe customer id") - return nil, err - } - - return stripeCustomer, nil -} diff --git a/internal/httpserve/handlers/ent.go b/internal/httpserve/handlers/ent.go index fed241a9..25d40b1b 100644 --- a/internal/httpserve/handlers/ent.go +++ b/internal/httpserve/handlers/ent.go @@ -499,40 +499,3 @@ func (h *Handler) getOrgByID(ctx context.Context, id string) (*ent.Organization, return org, nil } - -// getOrgSettingByOrgID returns the organization settings from an organization ID and context -func (h *Handler) getOrgSettingByOrgID(ctx context.Context, orgID string) (*ent.OrganizationSetting, error) { - org, err := h.getOrgByID(ctx, orgID) - if err != nil { - log.Error().Err(err).Msg("error retrieving organization") - - return nil, err - } - - if org.PersonalOrg { - log.Error().Msg("personal orgs do not have billing information") - - return nil, ErrPersonalOrgsNoBilling - } - - setting, err := org.Setting(ctx) - if err != nil { - log.Error().Err(err).Msg("error retrieving organization setting") - - return nil, err - } - - return setting, nil -} - -func (h *Handler) updateOrganizationSettingWithCustomerID(ctx context.Context, orgsettingID, customerID string) error { - if _, err := transaction.FromContext(ctx).OrganizationSetting.UpdateOneID(orgsettingID). - SetStripeID(customerID). - Save(ctx); err != nil { - log.Error().Err(err).Msg("error updating organization setting with stripe customer id") - - return err - } - - return nil -} diff --git a/internal/httpserve/route/checkout.go b/internal/httpserve/route/checkout.go deleted file mode 100644 index 6a0b8c4d..00000000 --- a/internal/httpserve/route/checkout.go +++ /dev/null @@ -1,53 +0,0 @@ -package route - -import ( - "net/http" - - echo "github.com/theopenlane/echox" -) - -// registerCheckoutSessionHandler registers the checkout session handler -func registerCheckoutSessionHandler(router *Router) (err error) { - path := "/checkout/session" - method := http.MethodGet - name := "CheckoutSession" - - route := echo.Route{ - Name: name, - Method: method, - Path: path, - Middlewares: authMW, - Handler: func(c echo.Context) error { - return router.Handler.CheckoutSessionHandler(c) - }, - } - - if err := router.Addv1Route(path, method, nil, route); err != nil { - return err - } - - return nil -} - -// registerCheckoutSuccessHandler registers the checkout success handler -func registerCheckoutSuccessHandler(router *Router) (err error) { - path := "/checkout/success" - method := http.MethodGet - name := "CheckoutSuccess" - - route := echo.Route{ - Name: name, - Method: method, - Path: path, - Middlewares: authMW, - Handler: func(c echo.Context) error { - return router.Handler.CheckoutSuccessHandler(c) - }, - } - - if err := router.Addv1Route(path, method, nil, route); err != nil { - return err - } - - return nil -} diff --git a/internal/httpserve/route/router.go b/internal/httpserve/route/router.go index ecdba410..4bbc7446 100644 --- a/internal/httpserve/route/router.go +++ b/internal/httpserve/route/router.go @@ -203,13 +203,6 @@ func RegisterRoutes(router *Router) error { registerAppleMerchantHandler, } - // add the checkout handlers if the entitlements are enabled - if router.Handler.Entitlements != nil { - routeHandlers = append(routeHandlers, - registerCheckoutSessionHandler, - registerCheckoutSuccessHandler) - } - for _, route := range routeHandlers { if err := route.(func(*Router) error)(router); err != nil { return err diff --git a/pkg/entitlements/customers.go b/pkg/entitlements/customers.go index 3059b998..89ced1f2 100644 --- a/pkg/entitlements/customers.go +++ b/pkg/entitlements/customers.go @@ -74,7 +74,20 @@ func (sc *StripeClient) FindorCreateCustomer(ctx context.Context, o *Organizatio return nil, err } + subs, err := sc.CreateTrialSubscription(customer.ID) + if err != nil { + return nil, err + } + o.StripeCustomerID = customer.ID + o.Subscription = *subs + + feats, err := sc.retrieveActiveEntitlements(customer.ID) + if err != nil { + return nil, err + } + + o.Features = feats return o, nil case 1: diff --git a/pkg/entitlements/helpers.go b/pkg/entitlements/helpers.go index 09bd8064..89c3bfbf 100644 --- a/pkg/entitlements/helpers.go +++ b/pkg/entitlements/helpers.go @@ -71,10 +71,9 @@ func (sc *StripeClient) GetProducts() []Product { } features = append(features, Feature{ - ID: feature.FeatureID, - ProductFeatureID: feature.ProductFeatureID, - Name: feature.Name, - Lookupkey: feature.Lookupkey, + ID: feature.FeatureID, + Name: feature.Name, + Lookupkey: feature.Lookupkey, }) } @@ -105,10 +104,9 @@ func (sc *StripeClient) GetProductFeatures(productID string) []ProductFeature { for list.Next() { if list.ProductFeature().ID != "" { productfeatures = append(productfeatures, ProductFeature{ - ProductFeatureID: list.ProductFeature().ID, - FeatureID: list.ProductFeature().EntitlementFeature.ID, - Name: list.ProductFeature().EntitlementFeature.Name, - Lookupkey: list.ProductFeature().EntitlementFeature.LookupKey, + FeatureID: list.ProductFeature().EntitlementFeature.ID, + Name: list.ProductFeature().EntitlementFeature.Name, + Lookupkey: list.ProductFeature().EntitlementFeature.LookupKey, }) } } diff --git a/pkg/entitlements/models.go b/pkg/entitlements/models.go index ac58a4c5..94646a0d 100644 --- a/pkg/entitlements/models.go +++ b/pkg/entitlements/models.go @@ -15,6 +15,8 @@ type OrganizationCustomer struct { BillingEmail string `json:"billing_email"` BillingPhone string `json:"billing_phone"` OrganizationName string `json:"organization_name"` + Features []string + Subscription } // MapToStripeCustomer maps the OrganizationCustomer to a stripe customer for more easy querying @@ -97,7 +99,7 @@ type Subscription struct { type Product struct { ID string `json:"product_id" yaml:"product_id"` Name string `json:"name" yaml:"name"` - Description string `json:"description" yaml:"description"` + Description string `json:"description,omitempty" yaml:"description,omitempty"` Features []Feature `json:"features" yaml:"features"` Prices []Price `json:"prices" yaml:"prices"` StripeParams *stripe.ProductParams `json:"stripe_params,omitempty" yaml:"stripe_params,omitempty"` @@ -108,7 +110,7 @@ type Product struct { type Price struct { ID string `json:"price_id" yaml:"price_id"` Price float64 `json:"price" yaml:"price"` - ProductID string `json:"product_id" yaml:"product_id"` + ProductID string `json:"product_id" yaml:"-"` Interval string `json:"interval" yaml:"interval"` StripeParams *stripe.PriceParams `json:"stripe_params,omitempty" yaml:"stripe_params,omitempty"` StripePrice []stripe.Price `json:"stripe_price,omitempty" yaml:"stripe_price,omitempty"` @@ -122,16 +124,14 @@ type Checkout struct { // Feature are part of a product type Feature struct { - ID string `json:"id" yaml:"id"` - Name string `json:"name" yaml:"name"` - Lookupkey string `json:"lookupkey" yaml:"lookupkey"` - ProductFeatureID string `json:"product_feature_id" yaml:"product_feature_id"` + ID string `json:"id" yaml:"id"` + Name string `json:"name" yaml:"name"` + Lookupkey string `json:"lookupkey" yaml:"lookupkey"` } type ProductFeature struct { - ProductFeatureID string `json:"product_feature_id" yaml:"product_feature_id"` - FeatureID string `json:"feature_id" yaml:"feature_id"` - ProductID string `json:"product_id" yaml:"product_id"` - Name string `json:"name" yaml:"name"` - Lookupkey string `json:"lookupkey" yaml:"lookupkey"` + FeatureID string `json:"feature_id" yaml:"feature_id"` + ProductID string `json:"product_id"` + Name string `json:"name" yaml:"name"` + Lookupkey string `json:"lookupkey" yaml:"lookupkey"` } diff --git a/pkg/entitlements/subscriptions.go b/pkg/entitlements/subscriptions.go index 2fc0ced9..d7cd0fb9 100644 --- a/pkg/entitlements/subscriptions.go +++ b/pkg/entitlements/subscriptions.go @@ -131,38 +131,44 @@ func (sc *StripeClient) CreateBillingPortalUpdateSession(subsID, custID string) }, nil } +func (sc *StripeClient) retrieveActiveEntitlements(customerID string) ([]string, error) { + params := &stripe.EntitlementsActiveEntitlementListParams{ + Customer: stripe.String(customerID), + Expand: []*string{stripe.String("data.feature")}, + } + + iter := sc.Client.EntitlementsActiveEntitlements.List(params) + + if !iter.Next() { + return nil, iter.Err() + } + + feat := []string{} + for iter.Next() { + feat = append(feat, iter.EntitlementsActiveEntitlement().LookupKey) + } + + return feat, nil +} + // mapStripeSubscription maps a stripe.Subscription to a "internal" subscription struct func (sc *StripeClient) mapStripeSubscription(subs *stripe.Subscription) *Subscription { subscript := Subscription{} - var prices []Price + prices := []Price{} for _, item := range subs.Items.Data { prices = append(prices, Price{ ID: item.Price.ID, - Price: float64(item.Price.UnitAmount), + Price: float64(item.Price.UnitAmount) / 100, // nolint:mnd ProductID: item.Price.Product.ID, Interval: string(item.Price.Recurring.Interval), }) - } - for _, product := range prices { - prodFeat := sc.GetProductFeatures(product.ProductID) - for _, feature := range prodFeat { - featureList := []Feature{ - { - ID: feature.FeatureID, - ProductFeatureID: feature.ProductFeatureID, - Name: feature.Name, - Lookupkey: feature.Lookupkey, - }, - } - - subscript.Features = append(subscript.Features, featureList...) - } + subscript.Prices = append(subscript.Prices, prices...) } - subscription := &Subscription{ + return &Subscription{ ID: subs.ID, Prices: prices, StartDate: subs.CurrentPeriodStart, @@ -174,8 +180,6 @@ func (sc *StripeClient) mapStripeSubscription(subs *stripe.Subscription) *Subscr DaysUntilDue: subs.DaysUntilDue, Features: subscript.Features, } - - return subscription } type Subs struct { diff --git a/pkg/entitlements/test/main.go b/pkg/entitlements/test/main.go index 1fc86816..3d5b43f2 100644 --- a/pkg/entitlements/test/main.go +++ b/pkg/entitlements/test/main.go @@ -1,6 +1,8 @@ package main import ( + "sort" + "github.com/rs/zerolog/log" "github.com/theopenlane/core/pkg/entitlements" @@ -13,6 +15,8 @@ func main() { plans := client.GetProducts() + sortPlansByFeatureCount(plans) + // Write the plans to a YAML file err := entitlements.WritePlansToYAML(plans, "pkg/entitlements/test/plans.yaml") if err != nil { @@ -26,3 +30,10 @@ func initStripeClient() entitlements.StripeClient { client := entitlements.NewStripeClient(entitlements.WithAPIKey("")) return *client } + +// sortPlansByFeatureCount sorts the plans by the count of features in each plan +func sortPlansByFeatureCount(plans []entitlements.Product) { + sort.Slice(plans, func(i, j int) bool { + return len(plans[i].Features) < len(plans[j].Features) + }) +} diff --git a/pkg/entitlements/test/plans.yaml b/pkg/entitlements/test/plans.yaml index 5e0aec13..9ae012ea 100644 --- a/pkg/entitlements/test/plans.yaml +++ b/pkg/entitlements/test/plans.yaml @@ -1,63 +1,102 @@ -- product_id: prod_RClqj0AttVzg4k - name: Enterprise Tier - description: "" +- product_id: prod_RClVi0ZeIWJHOR + name: Starter Tier features: + - id: feat_61RSmLtyXmxzlTaC541Bvxky1R7Sv8Qi + name: Centralized Audit Documentation + lookupkey: centralized-audit-docuemtnation + - id: feat_61RSmKVSYRqkKCRLg41Bvxky1R7SvRZg + name: Risk Management + lookupkey: risk-management + - id: feat_61RSmGpuIwzRc6sLb41Bvxky1R7Sv0NE + name: Policy and Procedure module + lookupkey: policy-and-procedure-module - id: feat_61RSmG7F7asoJOY4E41Bvxky1R7Sv9Im name: Compliance Module lookupkey: compliance-module - product_feature_id: prodft_1QKRHKBvxky1R7SvTtTepHP1 - - id: feat_61RSmKnFOpuguesvn41Bvxky1R7SvHqK - name: Vulnerability Management - lookupkey: vulnerability-management - product_feature_id: prodft_1QKRGtBvxky1R7Sv80VTF4Vr - - id: feat_61RSmMdzv0HRMJO4k41Bvxky1R7Sv3Ki - name: Continuous Monitoring - lookupkey: continuous-monitoring - product_feature_id: prodft_1QKRG8Bvxky1R7SvmQpcbJMo prices: - - price_id: price_1QKmuZBvxky1R7SvHAwybmEZ - price: 4000 - product_id: prod_RClqj0AttVzg4k + - price_id: price_1QKO97Bvxky1R7SvcMA1YYG1 + price: 1000 interval: year - - price_id: price_1QKMJ6Bvxky1R7SvgbFmumzr - price: 400 - product_id: prod_RClqj0AttVzg4k + - price_id: price_1QKLyeBvxky1R7SvaZYGWyQb + price: 100 interval: month - product_id: prod_RClW8LT3bzMeyG name: Business Tier - description: "" features: + - id: feat_61RSmLtyXmxzlTaC541Bvxky1R7Sv8Qi + name: Centralized Audit Documentation + lookupkey: centralized-audit-docuemtnation + - id: feat_61RSmKVSYRqkKCRLg41Bvxky1R7SvRZg + name: Risk Management + lookupkey: risk-management + - id: feat_61RSmGwlWtNg1oj2741Bvxky1R7Sv4Fk + name: Webhooks + lookupkey: webhooks + - id: feat_61RSmGVnjXfY2EN6b41Bvxky1R7SvOkC + name: Evidence Storage + lookupkey: evidence-storage + - id: feat_61RSmGKKl7dc5zJP341Bvxky1R7SvI0W + name: Questionaire Automation + lookupkey: questionaire-automation + - id: feat_61RSmGpuIwzRc6sLb41Bvxky1R7Sv0NE + name: Policy and Procedure module + lookupkey: policy-and-procedure-module - id: feat_61RSmG7F7asoJOY4E41Bvxky1R7Sv9Im name: Compliance Module lookupkey: compliance-module - product_feature_id: prodft_1QKRHKBvxky1R7SvfJahMY56 - id: feat_61RSmKnFOpuguesvn41Bvxky1R7SvHqK name: Vulnerability Management lookupkey: vulnerability-management - product_feature_id: prodft_1QKRGtBvxky1R7SvlyWOa09t prices: - price_id: price_1QKmtZBvxky1R7Sv1wNhoHRP price: 2500 - product_id: prod_RClW8LT3bzMeyG interval: year - price_id: price_1QKLzjBvxky1R7SvtvVT63Kn price: 250 - product_id: prod_RClW8LT3bzMeyG interval: month -- product_id: prod_RClVi0ZeIWJHOR - name: Starter Tier - description: "" +- product_id: prod_RClqj0AttVzg4k + name: Enterprise Tier features: + - id: feat_61RSmMOtfJd9bZgNM41Bvxky1R7SvApU + name: Employee Onboarding Automation + lookupkey: employee-onboarding-automation + - id: feat_61RSmLtyXmxzlTaC541Bvxky1R7Sv8Qi + name: Centralized Audit Documentation + lookupkey: centralized-audit-docuemtnation + - id: feat_61RSmKdT2wmqQdyK141Bvxky1R7SvPvk + name: Vendor Management + lookupkey: vendor-management + - id: feat_61RSmKVSYRqkKCRLg41Bvxky1R7SvRZg + name: Risk Management + lookupkey: risk-management + - id: feat_61RSmH50KcYFM4e7t41Bvxky1R7SvOPg + name: SSO + lookupkey: sso + - id: feat_61RSmGwlWtNg1oj2741Bvxky1R7Sv4Fk + name: Webhooks + lookupkey: webhooks + - id: feat_61RSmGVnjXfY2EN6b41Bvxky1R7SvOkC + name: Evidence Storage + lookupkey: evidence-storage + - id: feat_61RSmGKKl7dc5zJP341Bvxky1R7SvI0W + name: Questionaire Automation + lookupkey: questionaire-automation + - id: feat_61RSmGpuIwzRc6sLb41Bvxky1R7Sv0NE + name: Policy and Procedure module + lookupkey: policy-and-procedure-module - id: feat_61RSmG7F7asoJOY4E41Bvxky1R7Sv9Im name: Compliance Module lookupkey: compliance-module - product_feature_id: prodft_1QKRHKBvxky1R7Svrz8k8Wk4 + - id: feat_61RSmKnFOpuguesvn41Bvxky1R7SvHqK + name: Vulnerability Management + lookupkey: vulnerability-management + - id: feat_61RSmMdzv0HRMJO4k41Bvxky1R7Sv3Ki + name: Continuous Monitoring + lookupkey: continuous-monitoring prices: - - price_id: price_1QKO97Bvxky1R7SvcMA1YYG1 - price: 1000 - product_id: prod_RClVi0ZeIWJHOR + - price_id: price_1QKmuZBvxky1R7SvHAwybmEZ + price: 4000 interval: year - - price_id: price_1QKLyeBvxky1R7SvaZYGWyQb - price: 100 - product_id: prod_RClVi0ZeIWJHOR + - price_id: price_1QKMJ6Bvxky1R7SvgbFmumzr + price: 400 interval: month diff --git a/pkg/openlaneclient/graphclient.go b/pkg/openlaneclient/graphclient.go index e6e02767..5ceec411 100644 --- a/pkg/openlaneclient/graphclient.go +++ b/pkg/openlaneclient/graphclient.go @@ -246,6 +246,16 @@ type OpenlaneGraphClient interface { UpdateUserRoleInOrg(ctx context.Context, updateOrgMemberID string, input UpdateOrgMembershipInput, interceptors ...clientv2.RequestInterceptor) (*UpdateUserRoleInOrg, error) GetAllOrgMembershipHistories(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*GetAllOrgMembershipHistories, error) GetOrgMembershipHistories(ctx context.Context, where *OrgMembershipHistoryWhereInput, interceptors ...clientv2.RequestInterceptor) (*GetOrgMembershipHistories, error) + CreateBulkCSVOrgSubscription(ctx context.Context, input graphql.Upload, interceptors ...clientv2.RequestInterceptor) (*CreateBulkCSVOrgSubscription, error) + CreateBulkOrgSubscription(ctx context.Context, input []*CreateOrgSubscriptionInput, interceptors ...clientv2.RequestInterceptor) (*CreateBulkOrgSubscription, error) + CreateOrgSubscription(ctx context.Context, input CreateOrgSubscriptionInput, interceptors ...clientv2.RequestInterceptor) (*CreateOrgSubscription, error) + DeleteOrgSubscription(ctx context.Context, deleteOrgSubscriptionID string, interceptors ...clientv2.RequestInterceptor) (*DeleteOrgSubscription, error) + GetAllOrgSubscriptions(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*GetAllOrgSubscriptions, error) + GetOrgSubscriptionByID(ctx context.Context, orgSubscriptionID string, interceptors ...clientv2.RequestInterceptor) (*GetOrgSubscriptionByID, error) + GetOrgSubscriptions(ctx context.Context, where *OrgSubscriptionWhereInput, interceptors ...clientv2.RequestInterceptor) (*GetOrgSubscriptions, error) + UpdateOrgSubscription(ctx context.Context, updateOrgSubscriptionID string, input UpdateOrgSubscriptionInput, interceptors ...clientv2.RequestInterceptor) (*UpdateOrgSubscription, error) + GetAllOrgSubscriptionHistories(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*GetAllOrgSubscriptionHistories, error) + GetOrgSubscriptionHistories(ctx context.Context, where *OrgSubscriptionHistoryWhereInput, interceptors ...clientv2.RequestInterceptor) (*GetOrgSubscriptionHistories, error) CreateBulkCSVPersonalAccessToken(ctx context.Context, input graphql.Upload, interceptors ...clientv2.RequestInterceptor) (*CreateBulkCSVPersonalAccessToken, error) CreateBulkPersonalAccessToken(ctx context.Context, input []*CreatePersonalAccessTokenInput, interceptors ...clientv2.RequestInterceptor) (*CreateBulkPersonalAccessToken, error) CreatePersonalAccessToken(ctx context.Context, input CreatePersonalAccessTokenInput, interceptors ...clientv2.RequestInterceptor) (*CreatePersonalAccessToken, error) @@ -3099,6 +3109,91 @@ func (t *AdminSearch_AdminSearch_Nodes_OhAuthTooTokenSearchResult) GetOhAuthTooT return t.OhAuthTooTokens } +type AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions struct { + ID string "json:\"id\" graphql:\"id\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + DeletedBy *string "json:\"deletedBy,omitempty\" graphql:\"deletedBy\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" +} + +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetID() string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.ID +} +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetTags() []string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.Tags +} +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetDeletedBy() *string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.DeletedBy +} +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetOwnerID() *string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.OwnerID +} +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetStripeSubscriptionID() *string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.StripeSubscriptionID +} +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetProductTier() *string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.ProductTier +} +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetStripeProductTierID() *string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.StripeProductTierID +} +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.StripeSubscriptionStatus +} +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetStripeCustomerID() *string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.StripeCustomerID +} +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetFeatures() []string { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.Features +} + +type AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult struct { + OrgSubscriptions []*AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions "json:\"orgSubscriptions,omitempty\" graphql:\"orgSubscriptions\"" +} + +func (t *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult) GetOrgSubscriptions() []*AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult{} + } + return t.OrgSubscriptions +} + type AdminSearch_AdminSearch_Nodes_OrganizationSearchResult_Organizations struct { ID string "json:\"id\" graphql:\"id\"" Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" @@ -4270,6 +4365,7 @@ type AdminSearch_AdminSearch_Nodes struct { NarrativeSearchResult AdminSearch_AdminSearch_Nodes_NarrativeSearchResult "graphql:\"... on NarrativeSearchResult\"" OauthProviderSearchResult AdminSearch_AdminSearch_Nodes_OauthProviderSearchResult "graphql:\"... on OauthProviderSearchResult\"" OhAuthTooTokenSearchResult AdminSearch_AdminSearch_Nodes_OhAuthTooTokenSearchResult "graphql:\"... on OhAuthTooTokenSearchResult\"" + OrgSubscriptionSearchResult AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult "graphql:\"... on OrgSubscriptionSearchResult\"" OrganizationSearchResult AdminSearch_AdminSearch_Nodes_OrganizationSearchResult "graphql:\"... on OrganizationSearchResult\"" OrganizationSettingSearchResult AdminSearch_AdminSearch_Nodes_OrganizationSettingSearchResult "graphql:\"... on OrganizationSettingSearchResult\"" PersonalAccessTokenSearchResult AdminSearch_AdminSearch_Nodes_PersonalAccessTokenSearchResult "graphql:\"... on PersonalAccessTokenSearchResult\"" @@ -4413,6 +4509,12 @@ func (t *AdminSearch_AdminSearch_Nodes) GetOhAuthTooTokenSearchResult() *AdminSe } return &t.OhAuthTooTokenSearchResult } +func (t *AdminSearch_AdminSearch_Nodes) GetOrgSubscriptionSearchResult() *AdminSearch_AdminSearch_Nodes_OrgSubscriptionSearchResult { + if t == nil { + t = &AdminSearch_AdminSearch_Nodes{} + } + return &t.OrgSubscriptionSearchResult +} func (t *AdminSearch_AdminSearch_Nodes) GetOrganizationSearchResult() *AdminSearch_AdminSearch_Nodes_OrganizationSearchResult { if t == nil { t = &AdminSearch_AdminSearch_Nodes{} @@ -33797,6 +33899,1172 @@ func (t *GetOrgMembershipHistories_OrgMembershipHistories) GetEdges() []*GetOrgM return t.Edges } +type CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions struct { + Active bool "json:\"active\" graphql:\"active\"" + CreatedAt *time.Time "json:\"createdAt,omitempty\" graphql:\"createdAt\"" + CreatedBy *string "json:\"createdBy,omitempty\" graphql:\"createdBy\"" + ExpiresAt *time.Time "json:\"expiresAt,omitempty\" graphql:\"expiresAt\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" + ID string "json:\"id\" graphql:\"id\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + UpdatedAt *time.Time "json:\"updatedAt,omitempty\" graphql:\"updatedAt\"" + UpdatedBy *string "json:\"updatedBy,omitempty\" graphql:\"updatedBy\"" +} + +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetActive() bool { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.Active +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetCreatedAt() *time.Time { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.CreatedAt +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetCreatedBy() *string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.CreatedBy +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetExpiresAt() *time.Time { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.ExpiresAt +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetFeatures() []string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.Features +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetID() string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.ID +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetOwnerID() *string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.OwnerID +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetProductTier() *string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.ProductTier +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetStripeCustomerID() *string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.StripeCustomerID +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetStripeProductTierID() *string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.StripeProductTierID +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetStripeSubscriptionID() *string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.StripeSubscriptionID +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.StripeSubscriptionStatus +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetTags() []string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.Tags +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetUpdatedAt() *time.Time { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.UpdatedAt +} +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions) GetUpdatedBy() *string { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions{} + } + return t.UpdatedBy +} + +type CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription struct { + OrgSubscriptions []*CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions "json:\"orgSubscriptions,omitempty\" graphql:\"orgSubscriptions\"" +} + +func (t *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription) GetOrgSubscriptions() []*CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription_OrgSubscriptions { + if t == nil { + t = &CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription{} + } + return t.OrgSubscriptions +} + +type CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions struct { + Active bool "json:\"active\" graphql:\"active\"" + CreatedAt *time.Time "json:\"createdAt,omitempty\" graphql:\"createdAt\"" + CreatedBy *string "json:\"createdBy,omitempty\" graphql:\"createdBy\"" + ExpiresAt *time.Time "json:\"expiresAt,omitempty\" graphql:\"expiresAt\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" + ID string "json:\"id\" graphql:\"id\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + UpdatedAt *time.Time "json:\"updatedAt,omitempty\" graphql:\"updatedAt\"" + UpdatedBy *string "json:\"updatedBy,omitempty\" graphql:\"updatedBy\"" +} + +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetActive() bool { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.Active +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetCreatedAt() *time.Time { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.CreatedAt +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetCreatedBy() *string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.CreatedBy +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetExpiresAt() *time.Time { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.ExpiresAt +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetFeatures() []string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.Features +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetID() string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.ID +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetOwnerID() *string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.OwnerID +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetProductTier() *string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.ProductTier +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetStripeCustomerID() *string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.StripeCustomerID +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetStripeProductTierID() *string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.StripeProductTierID +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetStripeSubscriptionID() *string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.StripeSubscriptionID +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.StripeSubscriptionStatus +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetTags() []string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.Tags +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetUpdatedAt() *time.Time { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.UpdatedAt +} +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions) GetUpdatedBy() *string { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions{} + } + return t.UpdatedBy +} + +type CreateBulkOrgSubscription_CreateBulkOrgSubscription struct { + OrgSubscriptions []*CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions "json:\"orgSubscriptions,omitempty\" graphql:\"orgSubscriptions\"" +} + +func (t *CreateBulkOrgSubscription_CreateBulkOrgSubscription) GetOrgSubscriptions() []*CreateBulkOrgSubscription_CreateBulkOrgSubscription_OrgSubscriptions { + if t == nil { + t = &CreateBulkOrgSubscription_CreateBulkOrgSubscription{} + } + return t.OrgSubscriptions +} + +type CreateOrgSubscription_CreateOrgSubscription_OrgSubscription struct { + Active bool "json:\"active\" graphql:\"active\"" + CreatedAt *time.Time "json:\"createdAt,omitempty\" graphql:\"createdAt\"" + CreatedBy *string "json:\"createdBy,omitempty\" graphql:\"createdBy\"" + ExpiresAt *time.Time "json:\"expiresAt,omitempty\" graphql:\"expiresAt\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" + ID string "json:\"id\" graphql:\"id\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + UpdatedAt *time.Time "json:\"updatedAt,omitempty\" graphql:\"updatedAt\"" + UpdatedBy *string "json:\"updatedBy,omitempty\" graphql:\"updatedBy\"" +} + +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetActive() bool { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.Active +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetCreatedAt() *time.Time { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.CreatedAt +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetCreatedBy() *string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.CreatedBy +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetExpiresAt() *time.Time { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.ExpiresAt +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetFeatures() []string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.Features +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetID() string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.ID +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetOwnerID() *string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.OwnerID +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetProductTier() *string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.ProductTier +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetStripeCustomerID() *string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.StripeCustomerID +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetStripeProductTierID() *string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.StripeProductTierID +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetStripeSubscriptionID() *string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.StripeSubscriptionID +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.StripeSubscriptionStatus +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetTags() []string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.Tags +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetUpdatedAt() *time.Time { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.UpdatedAt +} +func (t *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription) GetUpdatedBy() *string { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription_OrgSubscription{} + } + return t.UpdatedBy +} + +type CreateOrgSubscription_CreateOrgSubscription struct { + OrgSubscription CreateOrgSubscription_CreateOrgSubscription_OrgSubscription "json:\"orgSubscription\" graphql:\"orgSubscription\"" +} + +func (t *CreateOrgSubscription_CreateOrgSubscription) GetOrgSubscription() *CreateOrgSubscription_CreateOrgSubscription_OrgSubscription { + if t == nil { + t = &CreateOrgSubscription_CreateOrgSubscription{} + } + return &t.OrgSubscription +} + +type DeleteOrgSubscription_DeleteOrgSubscription struct { + DeletedID string "json:\"deletedID\" graphql:\"deletedID\"" +} + +func (t *DeleteOrgSubscription_DeleteOrgSubscription) GetDeletedID() string { + if t == nil { + t = &DeleteOrgSubscription_DeleteOrgSubscription{} + } + return t.DeletedID +} + +type GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node struct { + Active bool "json:\"active\" graphql:\"active\"" + CreatedAt *time.Time "json:\"createdAt,omitempty\" graphql:\"createdAt\"" + CreatedBy *string "json:\"createdBy,omitempty\" graphql:\"createdBy\"" + ExpiresAt *time.Time "json:\"expiresAt,omitempty\" graphql:\"expiresAt\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" + ID string "json:\"id\" graphql:\"id\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + UpdatedAt *time.Time "json:\"updatedAt,omitempty\" graphql:\"updatedAt\"" + UpdatedBy *string "json:\"updatedBy,omitempty\" graphql:\"updatedBy\"" +} + +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetActive() bool { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.Active +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetCreatedAt() *time.Time { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.CreatedAt +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetCreatedBy() *string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.CreatedBy +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetExpiresAt() *time.Time { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.ExpiresAt +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetFeatures() []string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.Features +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetID() string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.ID +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetOwnerID() *string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.OwnerID +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetProductTier() *string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.ProductTier +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetStripeCustomerID() *string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.StripeCustomerID +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetStripeProductTierID() *string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.StripeProductTierID +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetStripeSubscriptionID() *string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.StripeSubscriptionID +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.StripeSubscriptionStatus +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetTags() []string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.Tags +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetUpdatedAt() *time.Time { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.UpdatedAt +} +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node) GetUpdatedBy() *string { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.UpdatedBy +} + +type GetAllOrgSubscriptions_OrgSubscriptions_Edges struct { + Node *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node "json:\"node,omitempty\" graphql:\"node\"" +} + +func (t *GetAllOrgSubscriptions_OrgSubscriptions_Edges) GetNode() *GetAllOrgSubscriptions_OrgSubscriptions_Edges_Node { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions_Edges{} + } + return t.Node +} + +type GetAllOrgSubscriptions_OrgSubscriptions struct { + Edges []*GetAllOrgSubscriptions_OrgSubscriptions_Edges "json:\"edges,omitempty\" graphql:\"edges\"" +} + +func (t *GetAllOrgSubscriptions_OrgSubscriptions) GetEdges() []*GetAllOrgSubscriptions_OrgSubscriptions_Edges { + if t == nil { + t = &GetAllOrgSubscriptions_OrgSubscriptions{} + } + return t.Edges +} + +type GetOrgSubscriptionByID_OrgSubscription struct { + Active bool "json:\"active\" graphql:\"active\"" + CreatedAt *time.Time "json:\"createdAt,omitempty\" graphql:\"createdAt\"" + CreatedBy *string "json:\"createdBy,omitempty\" graphql:\"createdBy\"" + ExpiresAt *time.Time "json:\"expiresAt,omitempty\" graphql:\"expiresAt\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" + ID string "json:\"id\" graphql:\"id\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + UpdatedAt *time.Time "json:\"updatedAt,omitempty\" graphql:\"updatedAt\"" + UpdatedBy *string "json:\"updatedBy,omitempty\" graphql:\"updatedBy\"" +} + +func (t *GetOrgSubscriptionByID_OrgSubscription) GetActive() bool { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.Active +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetCreatedAt() *time.Time { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.CreatedAt +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetCreatedBy() *string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.CreatedBy +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetExpiresAt() *time.Time { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.ExpiresAt +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetFeatures() []string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.Features +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetID() string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.ID +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetOwnerID() *string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.OwnerID +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetProductTier() *string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.ProductTier +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetStripeCustomerID() *string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.StripeCustomerID +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetStripeProductTierID() *string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.StripeProductTierID +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetStripeSubscriptionID() *string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.StripeSubscriptionID +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.StripeSubscriptionStatus +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetTags() []string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.Tags +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetUpdatedAt() *time.Time { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.UpdatedAt +} +func (t *GetOrgSubscriptionByID_OrgSubscription) GetUpdatedBy() *string { + if t == nil { + t = &GetOrgSubscriptionByID_OrgSubscription{} + } + return t.UpdatedBy +} + +type GetOrgSubscriptions_OrgSubscriptions_Edges_Node struct { + Active bool "json:\"active\" graphql:\"active\"" + CreatedAt *time.Time "json:\"createdAt,omitempty\" graphql:\"createdAt\"" + CreatedBy *string "json:\"createdBy,omitempty\" graphql:\"createdBy\"" + ExpiresAt *time.Time "json:\"expiresAt,omitempty\" graphql:\"expiresAt\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" + ID string "json:\"id\" graphql:\"id\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + UpdatedAt *time.Time "json:\"updatedAt,omitempty\" graphql:\"updatedAt\"" + UpdatedBy *string "json:\"updatedBy,omitempty\" graphql:\"updatedBy\"" +} + +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetActive() bool { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.Active +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetCreatedAt() *time.Time { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.CreatedAt +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetCreatedBy() *string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.CreatedBy +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetExpiresAt() *time.Time { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.ExpiresAt +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetFeatures() []string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.Features +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetID() string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.ID +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetOwnerID() *string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.OwnerID +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetProductTier() *string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.ProductTier +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetStripeCustomerID() *string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.StripeCustomerID +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetStripeProductTierID() *string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.StripeProductTierID +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetStripeSubscriptionID() *string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.StripeSubscriptionID +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.StripeSubscriptionStatus +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetTags() []string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.Tags +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetUpdatedAt() *time.Time { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.UpdatedAt +} +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges_Node) GetUpdatedBy() *string { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges_Node{} + } + return t.UpdatedBy +} + +type GetOrgSubscriptions_OrgSubscriptions_Edges struct { + Node *GetOrgSubscriptions_OrgSubscriptions_Edges_Node "json:\"node,omitempty\" graphql:\"node\"" +} + +func (t *GetOrgSubscriptions_OrgSubscriptions_Edges) GetNode() *GetOrgSubscriptions_OrgSubscriptions_Edges_Node { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions_Edges{} + } + return t.Node +} + +type GetOrgSubscriptions_OrgSubscriptions struct { + Edges []*GetOrgSubscriptions_OrgSubscriptions_Edges "json:\"edges,omitempty\" graphql:\"edges\"" +} + +func (t *GetOrgSubscriptions_OrgSubscriptions) GetEdges() []*GetOrgSubscriptions_OrgSubscriptions_Edges { + if t == nil { + t = &GetOrgSubscriptions_OrgSubscriptions{} + } + return t.Edges +} + +type UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription struct { + Active bool "json:\"active\" graphql:\"active\"" + CreatedAt *time.Time "json:\"createdAt,omitempty\" graphql:\"createdAt\"" + CreatedBy *string "json:\"createdBy,omitempty\" graphql:\"createdBy\"" + ExpiresAt *time.Time "json:\"expiresAt,omitempty\" graphql:\"expiresAt\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" + ID string "json:\"id\" graphql:\"id\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + UpdatedAt *time.Time "json:\"updatedAt,omitempty\" graphql:\"updatedAt\"" + UpdatedBy *string "json:\"updatedBy,omitempty\" graphql:\"updatedBy\"" +} + +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetActive() bool { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.Active +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetCreatedAt() *time.Time { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.CreatedAt +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetCreatedBy() *string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.CreatedBy +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetExpiresAt() *time.Time { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.ExpiresAt +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetFeatures() []string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.Features +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetID() string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.ID +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetOwnerID() *string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.OwnerID +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetProductTier() *string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.ProductTier +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetStripeCustomerID() *string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.StripeCustomerID +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetStripeProductTierID() *string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.StripeProductTierID +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetStripeSubscriptionID() *string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.StripeSubscriptionID +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.StripeSubscriptionStatus +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetTags() []string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.Tags +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetUpdatedAt() *time.Time { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.UpdatedAt +} +func (t *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription) GetUpdatedBy() *string { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription{} + } + return t.UpdatedBy +} + +type UpdateOrgSubscription_UpdateOrgSubscription struct { + OrgSubscription UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription "json:\"orgSubscription\" graphql:\"orgSubscription\"" +} + +func (t *UpdateOrgSubscription_UpdateOrgSubscription) GetOrgSubscription() *UpdateOrgSubscription_UpdateOrgSubscription_OrgSubscription { + if t == nil { + t = &UpdateOrgSubscription_UpdateOrgSubscription{} + } + return &t.OrgSubscription +} + +type GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node struct { + Active bool "json:\"active\" graphql:\"active\"" + CreatedAt *time.Time "json:\"createdAt,omitempty\" graphql:\"createdAt\"" + CreatedBy *string "json:\"createdBy,omitempty\" graphql:\"createdBy\"" + ExpiresAt *time.Time "json:\"expiresAt,omitempty\" graphql:\"expiresAt\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" + HistoryTime time.Time "json:\"historyTime\" graphql:\"historyTime\"" + ID string "json:\"id\" graphql:\"id\"" + Operation history.OpType "json:\"operation\" graphql:\"operation\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + Ref *string "json:\"ref,omitempty\" graphql:\"ref\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + UpdatedAt *time.Time "json:\"updatedAt,omitempty\" graphql:\"updatedAt\"" + UpdatedBy *string "json:\"updatedBy,omitempty\" graphql:\"updatedBy\"" +} + +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetActive() bool { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.Active +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetCreatedAt() *time.Time { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.CreatedAt +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetCreatedBy() *string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.CreatedBy +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetExpiresAt() *time.Time { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.ExpiresAt +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetFeatures() []string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.Features +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetHistoryTime() *time.Time { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return &t.HistoryTime +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetID() string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.ID +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetOperation() *history.OpType { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return &t.Operation +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetOwnerID() *string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.OwnerID +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetProductTier() *string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.ProductTier +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetRef() *string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.Ref +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetStripeCustomerID() *string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.StripeCustomerID +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetStripeProductTierID() *string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.StripeProductTierID +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetStripeSubscriptionID() *string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.StripeSubscriptionID +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.StripeSubscriptionStatus +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetTags() []string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.Tags +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetUpdatedAt() *time.Time { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.UpdatedAt +} +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetUpdatedBy() *string { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.UpdatedBy +} + +type GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges struct { + Node *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node "json:\"node,omitempty\" graphql:\"node\"" +} + +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges) GetNode() *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges{} + } + return t.Node +} + +type GetAllOrgSubscriptionHistories_OrgSubscriptionHistories struct { + Edges []*GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges "json:\"edges,omitempty\" graphql:\"edges\"" +} + +func (t *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories) GetEdges() []*GetAllOrgSubscriptionHistories_OrgSubscriptionHistories_Edges { + if t == nil { + t = &GetAllOrgSubscriptionHistories_OrgSubscriptionHistories{} + } + return t.Edges +} + +type GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node struct { + Active bool "json:\"active\" graphql:\"active\"" + CreatedAt *time.Time "json:\"createdAt,omitempty\" graphql:\"createdAt\"" + CreatedBy *string "json:\"createdBy,omitempty\" graphql:\"createdBy\"" + ExpiresAt *time.Time "json:\"expiresAt,omitempty\" graphql:\"expiresAt\"" + Features []string "json:\"features,omitempty\" graphql:\"features\"" + HistoryTime time.Time "json:\"historyTime\" graphql:\"historyTime\"" + ID string "json:\"id\" graphql:\"id\"" + Operation history.OpType "json:\"operation\" graphql:\"operation\"" + OwnerID *string "json:\"ownerID,omitempty\" graphql:\"ownerID\"" + ProductTier *string "json:\"productTier,omitempty\" graphql:\"productTier\"" + Ref *string "json:\"ref,omitempty\" graphql:\"ref\"" + StripeCustomerID *string "json:\"stripeCustomerID,omitempty\" graphql:\"stripeCustomerID\"" + StripeProductTierID *string "json:\"stripeProductTierID,omitempty\" graphql:\"stripeProductTierID\"" + StripeSubscriptionID *string "json:\"stripeSubscriptionID,omitempty\" graphql:\"stripeSubscriptionID\"" + StripeSubscriptionStatus *string "json:\"stripeSubscriptionStatus,omitempty\" graphql:\"stripeSubscriptionStatus\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" + UpdatedAt *time.Time "json:\"updatedAt,omitempty\" graphql:\"updatedAt\"" + UpdatedBy *string "json:\"updatedBy,omitempty\" graphql:\"updatedBy\"" +} + +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetActive() bool { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.Active +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetCreatedAt() *time.Time { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.CreatedAt +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetCreatedBy() *string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.CreatedBy +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetExpiresAt() *time.Time { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.ExpiresAt +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetFeatures() []string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.Features +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetHistoryTime() *time.Time { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return &t.HistoryTime +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetID() string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.ID +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetOperation() *history.OpType { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return &t.Operation +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetOwnerID() *string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.OwnerID +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetProductTier() *string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.ProductTier +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetRef() *string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.Ref +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetStripeCustomerID() *string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.StripeCustomerID +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetStripeProductTierID() *string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.StripeProductTierID +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetStripeSubscriptionID() *string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.StripeSubscriptionID +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetStripeSubscriptionStatus() *string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.StripeSubscriptionStatus +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetTags() []string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.Tags +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetUpdatedAt() *time.Time { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.UpdatedAt +} +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node) GetUpdatedBy() *string { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node{} + } + return t.UpdatedBy +} + +type GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges struct { + Node *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node "json:\"node,omitempty\" graphql:\"node\"" +} + +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges) GetNode() *GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges_Node { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges{} + } + return t.Node +} + +type GetOrgSubscriptionHistories_OrgSubscriptionHistories struct { + Edges []*GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges "json:\"edges,omitempty\" graphql:\"edges\"" +} + +func (t *GetOrgSubscriptionHistories_OrgSubscriptionHistories) GetEdges() []*GetOrgSubscriptionHistories_OrgSubscriptionHistories_Edges { + if t == nil { + t = &GetOrgSubscriptionHistories_OrgSubscriptionHistories{} + } + return t.Edges +} + type CreateBulkCSVPersonalAccessToken_CreateBulkCSVPersonalAccessToken_PersonalAccessTokens_Organizations struct { ID string "json:\"id\" graphql:\"id\"" Name string "json:\"name\" graphql:\"name\"" @@ -42571,6 +43839,35 @@ func (t *GlobalSearch_Search_Nodes_OhAuthTooTokenSearchResult) GetOhAuthTooToken return t.OhAuthTooTokens } +type GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions struct { + ID string "json:\"id\" graphql:\"id\"" + Tags []string "json:\"tags,omitempty\" graphql:\"tags\"" +} + +func (t *GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetID() string { + if t == nil { + t = &GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.ID +} +func (t *GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions) GetTags() []string { + if t == nil { + t = &GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions{} + } + return t.Tags +} + +type GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult struct { + OrgSubscriptions []*GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions "json:\"orgSubscriptions,omitempty\" graphql:\"orgSubscriptions\"" +} + +func (t *GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult) GetOrgSubscriptions() []*GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult_OrgSubscriptions { + if t == nil { + t = &GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult{} + } + return t.OrgSubscriptions +} + type GlobalSearch_Search_Nodes_OrganizationSearchResult_Organizations struct { DisplayName string "json:\"displayName\" graphql:\"displayName\"" ID string "json:\"id\" graphql:\"id\"" @@ -43063,6 +44360,7 @@ type GlobalSearch_Search_Nodes struct { NarrativeSearchResult GlobalSearch_Search_Nodes_NarrativeSearchResult "graphql:\"... on NarrativeSearchResult\"" OauthProviderSearchResult GlobalSearch_Search_Nodes_OauthProviderSearchResult "graphql:\"... on OauthProviderSearchResult\"" OhAuthTooTokenSearchResult GlobalSearch_Search_Nodes_OhAuthTooTokenSearchResult "graphql:\"... on OhAuthTooTokenSearchResult\"" + OrgSubscriptionSearchResult GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult "graphql:\"... on OrgSubscriptionSearchResult\"" OrganizationSearchResult GlobalSearch_Search_Nodes_OrganizationSearchResult "graphql:\"... on OrganizationSearchResult\"" OrganizationSettingSearchResult GlobalSearch_Search_Nodes_OrganizationSettingSearchResult "graphql:\"... on OrganizationSettingSearchResult\"" PersonalAccessTokenSearchResult GlobalSearch_Search_Nodes_PersonalAccessTokenSearchResult "graphql:\"... on PersonalAccessTokenSearchResult\"" @@ -43206,6 +44504,12 @@ func (t *GlobalSearch_Search_Nodes) GetOhAuthTooTokenSearchResult() *GlobalSearc } return &t.OhAuthTooTokenSearchResult } +func (t *GlobalSearch_Search_Nodes) GetOrgSubscriptionSearchResult() *GlobalSearch_Search_Nodes_OrgSubscriptionSearchResult { + if t == nil { + t = &GlobalSearch_Search_Nodes{} + } + return &t.OrgSubscriptionSearchResult +} func (t *GlobalSearch_Search_Nodes) GetOrganizationSearchResult() *GlobalSearch_Search_Nodes_OrganizationSearchResult { if t == nil { t = &GlobalSearch_Search_Nodes{} @@ -55095,6 +56399,116 @@ func (t *GetOrgMembershipHistories) GetOrgMembershipHistories() *GetOrgMembershi return &t.OrgMembershipHistories } +type CreateBulkCSVOrgSubscription struct { + CreateBulkCSVOrgSubscription CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription "json:\"createBulkCSVOrgSubscription\" graphql:\"createBulkCSVOrgSubscription\"" +} + +func (t *CreateBulkCSVOrgSubscription) GetCreateBulkCSVOrgSubscription() *CreateBulkCSVOrgSubscription_CreateBulkCSVOrgSubscription { + if t == nil { + t = &CreateBulkCSVOrgSubscription{} + } + return &t.CreateBulkCSVOrgSubscription +} + +type CreateBulkOrgSubscription struct { + CreateBulkOrgSubscription CreateBulkOrgSubscription_CreateBulkOrgSubscription "json:\"createBulkOrgSubscription\" graphql:\"createBulkOrgSubscription\"" +} + +func (t *CreateBulkOrgSubscription) GetCreateBulkOrgSubscription() *CreateBulkOrgSubscription_CreateBulkOrgSubscription { + if t == nil { + t = &CreateBulkOrgSubscription{} + } + return &t.CreateBulkOrgSubscription +} + +type CreateOrgSubscription struct { + CreateOrgSubscription CreateOrgSubscription_CreateOrgSubscription "json:\"createOrgSubscription\" graphql:\"createOrgSubscription\"" +} + +func (t *CreateOrgSubscription) GetCreateOrgSubscription() *CreateOrgSubscription_CreateOrgSubscription { + if t == nil { + t = &CreateOrgSubscription{} + } + return &t.CreateOrgSubscription +} + +type DeleteOrgSubscription struct { + DeleteOrgSubscription DeleteOrgSubscription_DeleteOrgSubscription "json:\"deleteOrgSubscription\" graphql:\"deleteOrgSubscription\"" +} + +func (t *DeleteOrgSubscription) GetDeleteOrgSubscription() *DeleteOrgSubscription_DeleteOrgSubscription { + if t == nil { + t = &DeleteOrgSubscription{} + } + return &t.DeleteOrgSubscription +} + +type GetAllOrgSubscriptions struct { + OrgSubscriptions GetAllOrgSubscriptions_OrgSubscriptions "json:\"orgSubscriptions\" graphql:\"orgSubscriptions\"" +} + +func (t *GetAllOrgSubscriptions) GetOrgSubscriptions() *GetAllOrgSubscriptions_OrgSubscriptions { + if t == nil { + t = &GetAllOrgSubscriptions{} + } + return &t.OrgSubscriptions +} + +type GetOrgSubscriptionByID struct { + OrgSubscription GetOrgSubscriptionByID_OrgSubscription "json:\"orgSubscription\" graphql:\"orgSubscription\"" +} + +func (t *GetOrgSubscriptionByID) GetOrgSubscription() *GetOrgSubscriptionByID_OrgSubscription { + if t == nil { + t = &GetOrgSubscriptionByID{} + } + return &t.OrgSubscription +} + +type GetOrgSubscriptions struct { + OrgSubscriptions GetOrgSubscriptions_OrgSubscriptions "json:\"orgSubscriptions\" graphql:\"orgSubscriptions\"" +} + +func (t *GetOrgSubscriptions) GetOrgSubscriptions() *GetOrgSubscriptions_OrgSubscriptions { + if t == nil { + t = &GetOrgSubscriptions{} + } + return &t.OrgSubscriptions +} + +type UpdateOrgSubscription struct { + UpdateOrgSubscription UpdateOrgSubscription_UpdateOrgSubscription "json:\"updateOrgSubscription\" graphql:\"updateOrgSubscription\"" +} + +func (t *UpdateOrgSubscription) GetUpdateOrgSubscription() *UpdateOrgSubscription_UpdateOrgSubscription { + if t == nil { + t = &UpdateOrgSubscription{} + } + return &t.UpdateOrgSubscription +} + +type GetAllOrgSubscriptionHistories struct { + OrgSubscriptionHistories GetAllOrgSubscriptionHistories_OrgSubscriptionHistories "json:\"orgSubscriptionHistories\" graphql:\"orgSubscriptionHistories\"" +} + +func (t *GetAllOrgSubscriptionHistories) GetOrgSubscriptionHistories() *GetAllOrgSubscriptionHistories_OrgSubscriptionHistories { + if t == nil { + t = &GetAllOrgSubscriptionHistories{} + } + return &t.OrgSubscriptionHistories +} + +type GetOrgSubscriptionHistories struct { + OrgSubscriptionHistories GetOrgSubscriptionHistories_OrgSubscriptionHistories "json:\"orgSubscriptionHistories\" graphql:\"orgSubscriptionHistories\"" +} + +func (t *GetOrgSubscriptionHistories) GetOrgSubscriptionHistories() *GetOrgSubscriptionHistories_OrgSubscriptionHistories { + if t == nil { + t = &GetOrgSubscriptionHistories{} + } + return &t.OrgSubscriptionHistories +} + type CreateBulkCSVPersonalAccessToken struct { CreateBulkCSVPersonalAccessToken CreateBulkCSVPersonalAccessToken_CreateBulkCSVPersonalAccessToken "json:\"createBulkCSVPersonalAccessToken\" graphql:\"createBulkCSVPersonalAccessToken\"" } @@ -57181,6 +58595,20 @@ const AdminSearchDocument = `query AdminSearch ($query: String!) { connectorData } } + ... on OrgSubscriptionSearchResult { + orgSubscriptions { + id + tags + deletedBy + ownerID + stripeSubscriptionID + productTier + stripeProductTierID + stripeSubscriptionStatus + stripeCustomerID + features + } + } ... on OrganizationSearchResult { organizations { id @@ -66734,6 +68162,399 @@ func (c *Client) GetOrgMembershipHistories(ctx context.Context, where *OrgMember return &res, nil } +const CreateBulkCSVOrgSubscriptionDocument = `mutation CreateBulkCSVOrgSubscription ($input: Upload!) { + createBulkCSVOrgSubscription(input: $input) { + orgSubscriptions { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } +} +` + +func (c *Client) CreateBulkCSVOrgSubscription(ctx context.Context, input graphql.Upload, interceptors ...clientv2.RequestInterceptor) (*CreateBulkCSVOrgSubscription, error) { + vars := map[string]any{ + "input": input, + } + + var res CreateBulkCSVOrgSubscription + if err := c.Client.Post(ctx, "CreateBulkCSVOrgSubscription", CreateBulkCSVOrgSubscriptionDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + +const CreateBulkOrgSubscriptionDocument = `mutation CreateBulkOrgSubscription ($input: [CreateOrgSubscriptionInput!]) { + createBulkOrgSubscription(input: $input) { + orgSubscriptions { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } +} +` + +func (c *Client) CreateBulkOrgSubscription(ctx context.Context, input []*CreateOrgSubscriptionInput, interceptors ...clientv2.RequestInterceptor) (*CreateBulkOrgSubscription, error) { + vars := map[string]any{ + "input": input, + } + + var res CreateBulkOrgSubscription + if err := c.Client.Post(ctx, "CreateBulkOrgSubscription", CreateBulkOrgSubscriptionDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + +const CreateOrgSubscriptionDocument = `mutation CreateOrgSubscription ($input: CreateOrgSubscriptionInput!) { + createOrgSubscription(input: $input) { + orgSubscription { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } +} +` + +func (c *Client) CreateOrgSubscription(ctx context.Context, input CreateOrgSubscriptionInput, interceptors ...clientv2.RequestInterceptor) (*CreateOrgSubscription, error) { + vars := map[string]any{ + "input": input, + } + + var res CreateOrgSubscription + if err := c.Client.Post(ctx, "CreateOrgSubscription", CreateOrgSubscriptionDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + +const DeleteOrgSubscriptionDocument = `mutation DeleteOrgSubscription ($deleteOrgSubscriptionId: ID!) { + deleteOrgSubscription(id: $deleteOrgSubscriptionId) { + deletedID + } +} +` + +func (c *Client) DeleteOrgSubscription(ctx context.Context, deleteOrgSubscriptionID string, interceptors ...clientv2.RequestInterceptor) (*DeleteOrgSubscription, error) { + vars := map[string]any{ + "deleteOrgSubscriptionId": deleteOrgSubscriptionID, + } + + var res DeleteOrgSubscription + if err := c.Client.Post(ctx, "DeleteOrgSubscription", DeleteOrgSubscriptionDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + +const GetAllOrgSubscriptionsDocument = `query GetAllOrgSubscriptions { + orgSubscriptions { + edges { + node { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } + } +} +` + +func (c *Client) GetAllOrgSubscriptions(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*GetAllOrgSubscriptions, error) { + vars := map[string]any{} + + var res GetAllOrgSubscriptions + if err := c.Client.Post(ctx, "GetAllOrgSubscriptions", GetAllOrgSubscriptionsDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + +const GetOrgSubscriptionByIDDocument = `query GetOrgSubscriptionByID ($orgSubscriptionId: ID!) { + orgSubscription(id: $orgSubscriptionId) { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } +} +` + +func (c *Client) GetOrgSubscriptionByID(ctx context.Context, orgSubscriptionID string, interceptors ...clientv2.RequestInterceptor) (*GetOrgSubscriptionByID, error) { + vars := map[string]any{ + "orgSubscriptionId": orgSubscriptionID, + } + + var res GetOrgSubscriptionByID + if err := c.Client.Post(ctx, "GetOrgSubscriptionByID", GetOrgSubscriptionByIDDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + +const GetOrgSubscriptionsDocument = `query GetOrgSubscriptions ($where: OrgSubscriptionWhereInput) { + orgSubscriptions(where: $where) { + edges { + node { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } + } +} +` + +func (c *Client) GetOrgSubscriptions(ctx context.Context, where *OrgSubscriptionWhereInput, interceptors ...clientv2.RequestInterceptor) (*GetOrgSubscriptions, error) { + vars := map[string]any{ + "where": where, + } + + var res GetOrgSubscriptions + if err := c.Client.Post(ctx, "GetOrgSubscriptions", GetOrgSubscriptionsDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + +const UpdateOrgSubscriptionDocument = `mutation UpdateOrgSubscription ($updateOrgSubscriptionId: ID!, $input: UpdateOrgSubscriptionInput!) { + updateOrgSubscription(id: $updateOrgSubscriptionId, input: $input) { + orgSubscription { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } +} +` + +func (c *Client) UpdateOrgSubscription(ctx context.Context, updateOrgSubscriptionID string, input UpdateOrgSubscriptionInput, interceptors ...clientv2.RequestInterceptor) (*UpdateOrgSubscription, error) { + vars := map[string]any{ + "updateOrgSubscriptionId": updateOrgSubscriptionID, + "input": input, + } + + var res UpdateOrgSubscription + if err := c.Client.Post(ctx, "UpdateOrgSubscription", UpdateOrgSubscriptionDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + +const GetAllOrgSubscriptionHistoriesDocument = `query GetAllOrgSubscriptionHistories { + orgSubscriptionHistories { + edges { + node { + active + createdAt + createdBy + expiresAt + features + historyTime + id + operation + ownerID + productTier + ref + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } + } +} +` + +func (c *Client) GetAllOrgSubscriptionHistories(ctx context.Context, interceptors ...clientv2.RequestInterceptor) (*GetAllOrgSubscriptionHistories, error) { + vars := map[string]any{} + + var res GetAllOrgSubscriptionHistories + if err := c.Client.Post(ctx, "GetAllOrgSubscriptionHistories", GetAllOrgSubscriptionHistoriesDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + +const GetOrgSubscriptionHistoriesDocument = `query GetOrgSubscriptionHistories ($where: OrgSubscriptionHistoryWhereInput) { + orgSubscriptionHistories(where: $where) { + edges { + node { + active + createdAt + createdBy + expiresAt + features + historyTime + id + operation + ownerID + productTier + ref + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } + } +} +` + +func (c *Client) GetOrgSubscriptionHistories(ctx context.Context, where *OrgSubscriptionHistoryWhereInput, interceptors ...clientv2.RequestInterceptor) (*GetOrgSubscriptionHistories, error) { + vars := map[string]any{ + "where": where, + } + + var res GetOrgSubscriptionHistories + if err := c.Client.Post(ctx, "GetOrgSubscriptionHistories", GetOrgSubscriptionHistoriesDocument, &res, vars, interceptors...); err != nil { + if c.Client.ParseDataWhenErrors { + return &res, err + } + + return nil, err + } + + return &res, nil +} + const CreateBulkCSVPersonalAccessTokenDocument = `mutation CreateBulkCSVPersonalAccessToken ($input: Upload!) { createBulkCSVPersonalAccessToken(input: $input) { personalAccessTokens { @@ -69336,6 +71157,12 @@ const GlobalSearchDocument = `query GlobalSearch ($query: String!) { tags } } + ... on OrgSubscriptionSearchResult { + orgSubscriptions { + id + tags + } + } ... on OrganizationSearchResult { organizations { displayName @@ -72680,6 +74507,16 @@ var DocumentOperationNames = map[string]string{ UpdateUserRoleInOrgDocument: "UpdateUserRoleInOrg", GetAllOrgMembershipHistoriesDocument: "GetAllOrgMembershipHistories", GetOrgMembershipHistoriesDocument: "GetOrgMembershipHistories", + CreateBulkCSVOrgSubscriptionDocument: "CreateBulkCSVOrgSubscription", + CreateBulkOrgSubscriptionDocument: "CreateBulkOrgSubscription", + CreateOrgSubscriptionDocument: "CreateOrgSubscription", + DeleteOrgSubscriptionDocument: "DeleteOrgSubscription", + GetAllOrgSubscriptionsDocument: "GetAllOrgSubscriptions", + GetOrgSubscriptionByIDDocument: "GetOrgSubscriptionByID", + GetOrgSubscriptionsDocument: "GetOrgSubscriptions", + UpdateOrgSubscriptionDocument: "UpdateOrgSubscription", + GetAllOrgSubscriptionHistoriesDocument: "GetAllOrgSubscriptionHistories", + GetOrgSubscriptionHistoriesDocument: "GetOrgSubscriptionHistories", CreateBulkCSVPersonalAccessTokenDocument: "CreateBulkCSVPersonalAccessToken", CreateBulkPersonalAccessTokenDocument: "CreateBulkPersonalAccessToken", CreatePersonalAccessTokenDocument: "CreatePersonalAccessToken", diff --git a/pkg/openlaneclient/models.go b/pkg/openlaneclient/models.go index 46f40a33..74c99ab2 100644 --- a/pkg/openlaneclient/models.go +++ b/pkg/openlaneclient/models.go @@ -3655,6 +3655,30 @@ type CreateOrgMembershipInput struct { EventIDs []string `json:"eventIDs,omitempty"` } +// CreateOrgSubscriptionInput is used for create OrgSubscription object. +// Input was generated by ent. +type CreateOrgSubscriptionInput struct { + // tags associated with the object + Tags []string `json:"tags,omitempty"` + // the stripe subscription id + StripeSubscriptionID *string `json:"stripeSubscriptionID,omitempty"` + // the common name of the product tier the subscription is associated with, e.g. starter tier + ProductTier *string `json:"productTier,omitempty"` + // the product id that represents the tier in stripe + StripeProductTierID *string `json:"stripeProductTierID,omitempty"` + // the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + StripeSubscriptionStatus *string `json:"stripeSubscriptionStatus,omitempty"` + // indicates if the subscription is active + Active *bool `json:"active,omitempty"` + // the customer ID the subscription is associated to + StripeCustomerID *string `json:"stripeCustomerID,omitempty"` + // the time the subscription is set to expire; only populated if subscription is cancelled + ExpiresAt *time.Time `json:"expiresAt,omitempty"` + // the features associated with the subscription + Features []string `json:"features,omitempty"` + OwnerID *string `json:"ownerID,omitempty"` +} + // CreateOrganizationInput is used for create Organization object. // Input was generated by ent. type CreateOrganizationInput struct { @@ -3688,6 +3712,7 @@ type CreateOrganizationInput struct { SettingID *string `json:"settingID,omitempty"` DocumentdatumIDs []string `json:"documentdatumIDs,omitempty"` EntitlementIDs []string `json:"entitlementIDs,omitempty"` + OrgsubscriptionIDs []string `json:"orgsubscriptionIDs,omitempty"` OrganizationEntitlementIDs []string `json:"organizationEntitlementIDs,omitempty"` PersonalAccessTokenIDs []string `json:"personalAccessTokenIDs,omitempty"` APITokenIDs []string `json:"apiTokenIDs,omitempty"` @@ -14265,6 +14290,593 @@ type OrgMembershipWhereInput struct { UserID *string `json:"userID,omitempty"` } +type OrgSubscription struct { + ID string `json:"id"` + CreatedAt *time.Time `json:"createdAt,omitempty"` + UpdatedAt *time.Time `json:"updatedAt,omitempty"` + CreatedBy *string `json:"createdBy,omitempty"` + UpdatedBy *string `json:"updatedBy,omitempty"` + // tags associated with the object + Tags []string `json:"tags,omitempty"` + DeletedAt *time.Time `json:"deletedAt,omitempty"` + DeletedBy *string `json:"deletedBy,omitempty"` + // the organization id that owns the object + OwnerID *string `json:"ownerID,omitempty"` + // the stripe subscription id + StripeSubscriptionID *string `json:"stripeSubscriptionID,omitempty"` + // the common name of the product tier the subscription is associated with, e.g. starter tier + ProductTier *string `json:"productTier,omitempty"` + // the product id that represents the tier in stripe + StripeProductTierID *string `json:"stripeProductTierID,omitempty"` + // the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + StripeSubscriptionStatus *string `json:"stripeSubscriptionStatus,omitempty"` + // indicates if the subscription is active + Active bool `json:"active"` + // the customer ID the subscription is associated to + StripeCustomerID *string `json:"stripeCustomerID,omitempty"` + // the time the subscription is set to expire; only populated if subscription is cancelled + ExpiresAt *time.Time `json:"expiresAt,omitempty"` + // the features associated with the subscription + Features []string `json:"features,omitempty"` + Owner *Organization `json:"owner,omitempty"` +} + +func (OrgSubscription) IsNode() {} + +// Return response for createBulkOrgSubscription mutation +type OrgSubscriptionBulkCreatePayload struct { + // Created orgSubscriptions + OrgSubscriptions []*OrgSubscription `json:"orgSubscriptions,omitempty"` +} + +// A connection to a list of items. +type OrgSubscriptionConnection struct { + // A list of edges. + Edges []*OrgSubscriptionEdge `json:"edges,omitempty"` + // Information to aid in pagination. + PageInfo *PageInfo `json:"pageInfo"` + // Identifies the total count of items in the connection. + TotalCount int64 `json:"totalCount"` +} + +// Return response for createOrgSubscription mutation +type OrgSubscriptionCreatePayload struct { + // Created orgSubscription + OrgSubscription *OrgSubscription `json:"orgSubscription"` +} + +// Return response for deleteOrgSubscription mutation +type OrgSubscriptionDeletePayload struct { + // Deleted orgSubscription ID + DeletedID string `json:"deletedID"` +} + +// An edge in a connection. +type OrgSubscriptionEdge struct { + // The item at the end of the edge. + Node *OrgSubscription `json:"node,omitempty"` + // A cursor for use in pagination. + Cursor string `json:"cursor"` +} + +type OrgSubscriptionHistory struct { + ID string `json:"id"` + HistoryTime time.Time `json:"historyTime"` + Ref *string `json:"ref,omitempty"` + Operation history.OpType `json:"operation"` + CreatedAt *time.Time `json:"createdAt,omitempty"` + UpdatedAt *time.Time `json:"updatedAt,omitempty"` + CreatedBy *string `json:"createdBy,omitempty"` + UpdatedBy *string `json:"updatedBy,omitempty"` + // tags associated with the object + Tags []string `json:"tags,omitempty"` + DeletedAt *time.Time `json:"deletedAt,omitempty"` + DeletedBy *string `json:"deletedBy,omitempty"` + // the organization id that owns the object + OwnerID *string `json:"ownerID,omitempty"` + // the stripe subscription id + StripeSubscriptionID *string `json:"stripeSubscriptionID,omitempty"` + // the common name of the product tier the subscription is associated with, e.g. starter tier + ProductTier *string `json:"productTier,omitempty"` + // the product id that represents the tier in stripe + StripeProductTierID *string `json:"stripeProductTierID,omitempty"` + // the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + StripeSubscriptionStatus *string `json:"stripeSubscriptionStatus,omitempty"` + // indicates if the subscription is active + Active bool `json:"active"` + // the customer ID the subscription is associated to + StripeCustomerID *string `json:"stripeCustomerID,omitempty"` + // the time the subscription is set to expire; only populated if subscription is cancelled + ExpiresAt *time.Time `json:"expiresAt,omitempty"` + // the features associated with the subscription + Features []string `json:"features,omitempty"` +} + +func (OrgSubscriptionHistory) IsNode() {} + +// A connection to a list of items. +type OrgSubscriptionHistoryConnection struct { + // A list of edges. + Edges []*OrgSubscriptionHistoryEdge `json:"edges,omitempty"` + // Information to aid in pagination. + PageInfo *PageInfo `json:"pageInfo"` + // Identifies the total count of items in the connection. + TotalCount int64 `json:"totalCount"` +} + +// An edge in a connection. +type OrgSubscriptionHistoryEdge struct { + // The item at the end of the edge. + Node *OrgSubscriptionHistory `json:"node,omitempty"` + // A cursor for use in pagination. + Cursor string `json:"cursor"` +} + +// OrgSubscriptionHistoryWhereInput is used for filtering OrgSubscriptionHistory objects. +// Input was generated by ent. +type OrgSubscriptionHistoryWhereInput struct { + Not *OrgSubscriptionHistoryWhereInput `json:"not,omitempty"` + And []*OrgSubscriptionHistoryWhereInput `json:"and,omitempty"` + Or []*OrgSubscriptionHistoryWhereInput `json:"or,omitempty"` + // id field predicates + ID *string `json:"id,omitempty"` + IDNeq *string `json:"idNEQ,omitempty"` + IDIn []string `json:"idIn,omitempty"` + IDNotIn []string `json:"idNotIn,omitempty"` + IDGt *string `json:"idGT,omitempty"` + IDGte *string `json:"idGTE,omitempty"` + IDLt *string `json:"idLT,omitempty"` + IDLte *string `json:"idLTE,omitempty"` + IDEqualFold *string `json:"idEqualFold,omitempty"` + IDContainsFold *string `json:"idContainsFold,omitempty"` + // history_time field predicates + HistoryTime *time.Time `json:"historyTime,omitempty"` + HistoryTimeNeq *time.Time `json:"historyTimeNEQ,omitempty"` + HistoryTimeIn []*time.Time `json:"historyTimeIn,omitempty"` + HistoryTimeNotIn []*time.Time `json:"historyTimeNotIn,omitempty"` + HistoryTimeGt *time.Time `json:"historyTimeGT,omitempty"` + HistoryTimeGte *time.Time `json:"historyTimeGTE,omitempty"` + HistoryTimeLt *time.Time `json:"historyTimeLT,omitempty"` + HistoryTimeLte *time.Time `json:"historyTimeLTE,omitempty"` + // ref field predicates + Ref *string `json:"ref,omitempty"` + RefNeq *string `json:"refNEQ,omitempty"` + RefIn []string `json:"refIn,omitempty"` + RefNotIn []string `json:"refNotIn,omitempty"` + RefGt *string `json:"refGT,omitempty"` + RefGte *string `json:"refGTE,omitempty"` + RefLt *string `json:"refLT,omitempty"` + RefLte *string `json:"refLTE,omitempty"` + RefContains *string `json:"refContains,omitempty"` + RefHasPrefix *string `json:"refHasPrefix,omitempty"` + RefHasSuffix *string `json:"refHasSuffix,omitempty"` + RefIsNil *bool `json:"refIsNil,omitempty"` + RefNotNil *bool `json:"refNotNil,omitempty"` + RefEqualFold *string `json:"refEqualFold,omitempty"` + RefContainsFold *string `json:"refContainsFold,omitempty"` + // operation field predicates + Operation *history.OpType `json:"operation,omitempty"` + OperationNeq *history.OpType `json:"operationNEQ,omitempty"` + OperationIn []history.OpType `json:"operationIn,omitempty"` + OperationNotIn []history.OpType `json:"operationNotIn,omitempty"` + // created_at field predicates + CreatedAt *time.Time `json:"createdAt,omitempty"` + CreatedAtNeq *time.Time `json:"createdAtNEQ,omitempty"` + CreatedAtIn []*time.Time `json:"createdAtIn,omitempty"` + CreatedAtNotIn []*time.Time `json:"createdAtNotIn,omitempty"` + CreatedAtGt *time.Time `json:"createdAtGT,omitempty"` + CreatedAtGte *time.Time `json:"createdAtGTE,omitempty"` + CreatedAtLt *time.Time `json:"createdAtLT,omitempty"` + CreatedAtLte *time.Time `json:"createdAtLTE,omitempty"` + CreatedAtIsNil *bool `json:"createdAtIsNil,omitempty"` + CreatedAtNotNil *bool `json:"createdAtNotNil,omitempty"` + // updated_at field predicates + UpdatedAt *time.Time `json:"updatedAt,omitempty"` + UpdatedAtNeq *time.Time `json:"updatedAtNEQ,omitempty"` + UpdatedAtIn []*time.Time `json:"updatedAtIn,omitempty"` + UpdatedAtNotIn []*time.Time `json:"updatedAtNotIn,omitempty"` + UpdatedAtGt *time.Time `json:"updatedAtGT,omitempty"` + UpdatedAtGte *time.Time `json:"updatedAtGTE,omitempty"` + UpdatedAtLt *time.Time `json:"updatedAtLT,omitempty"` + UpdatedAtLte *time.Time `json:"updatedAtLTE,omitempty"` + UpdatedAtIsNil *bool `json:"updatedAtIsNil,omitempty"` + UpdatedAtNotNil *bool `json:"updatedAtNotNil,omitempty"` + // created_by field predicates + CreatedBy *string `json:"createdBy,omitempty"` + CreatedByNeq *string `json:"createdByNEQ,omitempty"` + CreatedByIn []string `json:"createdByIn,omitempty"` + CreatedByNotIn []string `json:"createdByNotIn,omitempty"` + CreatedByGt *string `json:"createdByGT,omitempty"` + CreatedByGte *string `json:"createdByGTE,omitempty"` + CreatedByLt *string `json:"createdByLT,omitempty"` + CreatedByLte *string `json:"createdByLTE,omitempty"` + CreatedByContains *string `json:"createdByContains,omitempty"` + CreatedByHasPrefix *string `json:"createdByHasPrefix,omitempty"` + CreatedByHasSuffix *string `json:"createdByHasSuffix,omitempty"` + CreatedByIsNil *bool `json:"createdByIsNil,omitempty"` + CreatedByNotNil *bool `json:"createdByNotNil,omitempty"` + CreatedByEqualFold *string `json:"createdByEqualFold,omitempty"` + CreatedByContainsFold *string `json:"createdByContainsFold,omitempty"` + // updated_by field predicates + UpdatedBy *string `json:"updatedBy,omitempty"` + UpdatedByNeq *string `json:"updatedByNEQ,omitempty"` + UpdatedByIn []string `json:"updatedByIn,omitempty"` + UpdatedByNotIn []string `json:"updatedByNotIn,omitempty"` + UpdatedByGt *string `json:"updatedByGT,omitempty"` + UpdatedByGte *string `json:"updatedByGTE,omitempty"` + UpdatedByLt *string `json:"updatedByLT,omitempty"` + UpdatedByLte *string `json:"updatedByLTE,omitempty"` + UpdatedByContains *string `json:"updatedByContains,omitempty"` + UpdatedByHasPrefix *string `json:"updatedByHasPrefix,omitempty"` + UpdatedByHasSuffix *string `json:"updatedByHasSuffix,omitempty"` + UpdatedByIsNil *bool `json:"updatedByIsNil,omitempty"` + UpdatedByNotNil *bool `json:"updatedByNotNil,omitempty"` + UpdatedByEqualFold *string `json:"updatedByEqualFold,omitempty"` + UpdatedByContainsFold *string `json:"updatedByContainsFold,omitempty"` + // deleted_at field predicates + DeletedAt *time.Time `json:"deletedAt,omitempty"` + DeletedAtNeq *time.Time `json:"deletedAtNEQ,omitempty"` + DeletedAtIn []*time.Time `json:"deletedAtIn,omitempty"` + DeletedAtNotIn []*time.Time `json:"deletedAtNotIn,omitempty"` + DeletedAtGt *time.Time `json:"deletedAtGT,omitempty"` + DeletedAtGte *time.Time `json:"deletedAtGTE,omitempty"` + DeletedAtLt *time.Time `json:"deletedAtLT,omitempty"` + DeletedAtLte *time.Time `json:"deletedAtLTE,omitempty"` + DeletedAtIsNil *bool `json:"deletedAtIsNil,omitempty"` + DeletedAtNotNil *bool `json:"deletedAtNotNil,omitempty"` + // deleted_by field predicates + DeletedBy *string `json:"deletedBy,omitempty"` + DeletedByNeq *string `json:"deletedByNEQ,omitempty"` + DeletedByIn []string `json:"deletedByIn,omitempty"` + DeletedByNotIn []string `json:"deletedByNotIn,omitempty"` + DeletedByGt *string `json:"deletedByGT,omitempty"` + DeletedByGte *string `json:"deletedByGTE,omitempty"` + DeletedByLt *string `json:"deletedByLT,omitempty"` + DeletedByLte *string `json:"deletedByLTE,omitempty"` + DeletedByContains *string `json:"deletedByContains,omitempty"` + DeletedByHasPrefix *string `json:"deletedByHasPrefix,omitempty"` + DeletedByHasSuffix *string `json:"deletedByHasSuffix,omitempty"` + DeletedByIsNil *bool `json:"deletedByIsNil,omitempty"` + DeletedByNotNil *bool `json:"deletedByNotNil,omitempty"` + DeletedByEqualFold *string `json:"deletedByEqualFold,omitempty"` + DeletedByContainsFold *string `json:"deletedByContainsFold,omitempty"` + // owner_id field predicates + OwnerID *string `json:"ownerID,omitempty"` + OwnerIdneq *string `json:"ownerIDNEQ,omitempty"` + OwnerIDIn []string `json:"ownerIDIn,omitempty"` + OwnerIDNotIn []string `json:"ownerIDNotIn,omitempty"` + OwnerIdgt *string `json:"ownerIDGT,omitempty"` + OwnerIdgte *string `json:"ownerIDGTE,omitempty"` + OwnerIdlt *string `json:"ownerIDLT,omitempty"` + OwnerIdlte *string `json:"ownerIDLTE,omitempty"` + OwnerIDContains *string `json:"ownerIDContains,omitempty"` + OwnerIDHasPrefix *string `json:"ownerIDHasPrefix,omitempty"` + OwnerIDHasSuffix *string `json:"ownerIDHasSuffix,omitempty"` + OwnerIDIsNil *bool `json:"ownerIDIsNil,omitempty"` + OwnerIDNotNil *bool `json:"ownerIDNotNil,omitempty"` + OwnerIDEqualFold *string `json:"ownerIDEqualFold,omitempty"` + OwnerIDContainsFold *string `json:"ownerIDContainsFold,omitempty"` + // stripe_subscription_id field predicates + StripeSubscriptionID *string `json:"stripeSubscriptionID,omitempty"` + StripeSubscriptionIdneq *string `json:"stripeSubscriptionIDNEQ,omitempty"` + StripeSubscriptionIDIn []string `json:"stripeSubscriptionIDIn,omitempty"` + StripeSubscriptionIDNotIn []string `json:"stripeSubscriptionIDNotIn,omitempty"` + StripeSubscriptionIdgt *string `json:"stripeSubscriptionIDGT,omitempty"` + StripeSubscriptionIdgte *string `json:"stripeSubscriptionIDGTE,omitempty"` + StripeSubscriptionIdlt *string `json:"stripeSubscriptionIDLT,omitempty"` + StripeSubscriptionIdlte *string `json:"stripeSubscriptionIDLTE,omitempty"` + StripeSubscriptionIDContains *string `json:"stripeSubscriptionIDContains,omitempty"` + StripeSubscriptionIDHasPrefix *string `json:"stripeSubscriptionIDHasPrefix,omitempty"` + StripeSubscriptionIDHasSuffix *string `json:"stripeSubscriptionIDHasSuffix,omitempty"` + StripeSubscriptionIDIsNil *bool `json:"stripeSubscriptionIDIsNil,omitempty"` + StripeSubscriptionIDNotNil *bool `json:"stripeSubscriptionIDNotNil,omitempty"` + StripeSubscriptionIDEqualFold *string `json:"stripeSubscriptionIDEqualFold,omitempty"` + StripeSubscriptionIDContainsFold *string `json:"stripeSubscriptionIDContainsFold,omitempty"` + // product_tier field predicates + ProductTier *string `json:"productTier,omitempty"` + ProductTierNeq *string `json:"productTierNEQ,omitempty"` + ProductTierIn []string `json:"productTierIn,omitempty"` + ProductTierNotIn []string `json:"productTierNotIn,omitempty"` + ProductTierGt *string `json:"productTierGT,omitempty"` + ProductTierGte *string `json:"productTierGTE,omitempty"` + ProductTierLt *string `json:"productTierLT,omitempty"` + ProductTierLte *string `json:"productTierLTE,omitempty"` + ProductTierContains *string `json:"productTierContains,omitempty"` + ProductTierHasPrefix *string `json:"productTierHasPrefix,omitempty"` + ProductTierHasSuffix *string `json:"productTierHasSuffix,omitempty"` + ProductTierIsNil *bool `json:"productTierIsNil,omitempty"` + ProductTierNotNil *bool `json:"productTierNotNil,omitempty"` + ProductTierEqualFold *string `json:"productTierEqualFold,omitempty"` + ProductTierContainsFold *string `json:"productTierContainsFold,omitempty"` + // stripe_product_tier_id field predicates + StripeProductTierID *string `json:"stripeProductTierID,omitempty"` + StripeProductTierIdneq *string `json:"stripeProductTierIDNEQ,omitempty"` + StripeProductTierIDIn []string `json:"stripeProductTierIDIn,omitempty"` + StripeProductTierIDNotIn []string `json:"stripeProductTierIDNotIn,omitempty"` + StripeProductTierIdgt *string `json:"stripeProductTierIDGT,omitempty"` + StripeProductTierIdgte *string `json:"stripeProductTierIDGTE,omitempty"` + StripeProductTierIdlt *string `json:"stripeProductTierIDLT,omitempty"` + StripeProductTierIdlte *string `json:"stripeProductTierIDLTE,omitempty"` + StripeProductTierIDContains *string `json:"stripeProductTierIDContains,omitempty"` + StripeProductTierIDHasPrefix *string `json:"stripeProductTierIDHasPrefix,omitempty"` + StripeProductTierIDHasSuffix *string `json:"stripeProductTierIDHasSuffix,omitempty"` + StripeProductTierIDIsNil *bool `json:"stripeProductTierIDIsNil,omitempty"` + StripeProductTierIDNotNil *bool `json:"stripeProductTierIDNotNil,omitempty"` + StripeProductTierIDEqualFold *string `json:"stripeProductTierIDEqualFold,omitempty"` + StripeProductTierIDContainsFold *string `json:"stripeProductTierIDContainsFold,omitempty"` + // stripe_subscription_status field predicates + StripeSubscriptionStatus *string `json:"stripeSubscriptionStatus,omitempty"` + StripeSubscriptionStatusNeq *string `json:"stripeSubscriptionStatusNEQ,omitempty"` + StripeSubscriptionStatusIn []string `json:"stripeSubscriptionStatusIn,omitempty"` + StripeSubscriptionStatusNotIn []string `json:"stripeSubscriptionStatusNotIn,omitempty"` + StripeSubscriptionStatusGt *string `json:"stripeSubscriptionStatusGT,omitempty"` + StripeSubscriptionStatusGte *string `json:"stripeSubscriptionStatusGTE,omitempty"` + StripeSubscriptionStatusLt *string `json:"stripeSubscriptionStatusLT,omitempty"` + StripeSubscriptionStatusLte *string `json:"stripeSubscriptionStatusLTE,omitempty"` + StripeSubscriptionStatusContains *string `json:"stripeSubscriptionStatusContains,omitempty"` + StripeSubscriptionStatusHasPrefix *string `json:"stripeSubscriptionStatusHasPrefix,omitempty"` + StripeSubscriptionStatusHasSuffix *string `json:"stripeSubscriptionStatusHasSuffix,omitempty"` + StripeSubscriptionStatusIsNil *bool `json:"stripeSubscriptionStatusIsNil,omitempty"` + StripeSubscriptionStatusNotNil *bool `json:"stripeSubscriptionStatusNotNil,omitempty"` + StripeSubscriptionStatusEqualFold *string `json:"stripeSubscriptionStatusEqualFold,omitempty"` + StripeSubscriptionStatusContainsFold *string `json:"stripeSubscriptionStatusContainsFold,omitempty"` + // active field predicates + Active *bool `json:"active,omitempty"` + ActiveNeq *bool `json:"activeNEQ,omitempty"` + // stripe_customer_id field predicates + StripeCustomerID *string `json:"stripeCustomerID,omitempty"` + StripeCustomerIdneq *string `json:"stripeCustomerIDNEQ,omitempty"` + StripeCustomerIDIn []string `json:"stripeCustomerIDIn,omitempty"` + StripeCustomerIDNotIn []string `json:"stripeCustomerIDNotIn,omitempty"` + StripeCustomerIdgt *string `json:"stripeCustomerIDGT,omitempty"` + StripeCustomerIdgte *string `json:"stripeCustomerIDGTE,omitempty"` + StripeCustomerIdlt *string `json:"stripeCustomerIDLT,omitempty"` + StripeCustomerIdlte *string `json:"stripeCustomerIDLTE,omitempty"` + StripeCustomerIDContains *string `json:"stripeCustomerIDContains,omitempty"` + StripeCustomerIDHasPrefix *string `json:"stripeCustomerIDHasPrefix,omitempty"` + StripeCustomerIDHasSuffix *string `json:"stripeCustomerIDHasSuffix,omitempty"` + StripeCustomerIDIsNil *bool `json:"stripeCustomerIDIsNil,omitempty"` + StripeCustomerIDNotNil *bool `json:"stripeCustomerIDNotNil,omitempty"` + StripeCustomerIDEqualFold *string `json:"stripeCustomerIDEqualFold,omitempty"` + StripeCustomerIDContainsFold *string `json:"stripeCustomerIDContainsFold,omitempty"` + // expires_at field predicates + ExpiresAt *time.Time `json:"expiresAt,omitempty"` + ExpiresAtNeq *time.Time `json:"expiresAtNEQ,omitempty"` + ExpiresAtIn []*time.Time `json:"expiresAtIn,omitempty"` + ExpiresAtNotIn []*time.Time `json:"expiresAtNotIn,omitempty"` + ExpiresAtGt *time.Time `json:"expiresAtGT,omitempty"` + ExpiresAtGte *time.Time `json:"expiresAtGTE,omitempty"` + ExpiresAtLt *time.Time `json:"expiresAtLT,omitempty"` + ExpiresAtLte *time.Time `json:"expiresAtLTE,omitempty"` + ExpiresAtIsNil *bool `json:"expiresAtIsNil,omitempty"` + ExpiresAtNotNil *bool `json:"expiresAtNotNil,omitempty"` +} + +type OrgSubscriptionSearchResult struct { + OrgSubscriptions []*OrgSubscription `json:"orgSubscriptions,omitempty"` +} + +func (OrgSubscriptionSearchResult) IsSearchResult() {} + +// Return response for updateOrgSubscription mutation +type OrgSubscriptionUpdatePayload struct { + // Updated orgSubscription + OrgSubscription *OrgSubscription `json:"orgSubscription"` +} + +// OrgSubscriptionWhereInput is used for filtering OrgSubscription objects. +// Input was generated by ent. +type OrgSubscriptionWhereInput struct { + Not *OrgSubscriptionWhereInput `json:"not,omitempty"` + And []*OrgSubscriptionWhereInput `json:"and,omitempty"` + Or []*OrgSubscriptionWhereInput `json:"or,omitempty"` + // id field predicates + ID *string `json:"id,omitempty"` + IDNeq *string `json:"idNEQ,omitempty"` + IDIn []string `json:"idIn,omitempty"` + IDNotIn []string `json:"idNotIn,omitempty"` + IDGt *string `json:"idGT,omitempty"` + IDGte *string `json:"idGTE,omitempty"` + IDLt *string `json:"idLT,omitempty"` + IDLte *string `json:"idLTE,omitempty"` + IDEqualFold *string `json:"idEqualFold,omitempty"` + IDContainsFold *string `json:"idContainsFold,omitempty"` + // created_at field predicates + CreatedAt *time.Time `json:"createdAt,omitempty"` + CreatedAtNeq *time.Time `json:"createdAtNEQ,omitempty"` + CreatedAtIn []*time.Time `json:"createdAtIn,omitempty"` + CreatedAtNotIn []*time.Time `json:"createdAtNotIn,omitempty"` + CreatedAtGt *time.Time `json:"createdAtGT,omitempty"` + CreatedAtGte *time.Time `json:"createdAtGTE,omitempty"` + CreatedAtLt *time.Time `json:"createdAtLT,omitempty"` + CreatedAtLte *time.Time `json:"createdAtLTE,omitempty"` + CreatedAtIsNil *bool `json:"createdAtIsNil,omitempty"` + CreatedAtNotNil *bool `json:"createdAtNotNil,omitempty"` + // updated_at field predicates + UpdatedAt *time.Time `json:"updatedAt,omitempty"` + UpdatedAtNeq *time.Time `json:"updatedAtNEQ,omitempty"` + UpdatedAtIn []*time.Time `json:"updatedAtIn,omitempty"` + UpdatedAtNotIn []*time.Time `json:"updatedAtNotIn,omitempty"` + UpdatedAtGt *time.Time `json:"updatedAtGT,omitempty"` + UpdatedAtGte *time.Time `json:"updatedAtGTE,omitempty"` + UpdatedAtLt *time.Time `json:"updatedAtLT,omitempty"` + UpdatedAtLte *time.Time `json:"updatedAtLTE,omitempty"` + UpdatedAtIsNil *bool `json:"updatedAtIsNil,omitempty"` + UpdatedAtNotNil *bool `json:"updatedAtNotNil,omitempty"` + // created_by field predicates + CreatedBy *string `json:"createdBy,omitempty"` + CreatedByNeq *string `json:"createdByNEQ,omitempty"` + CreatedByIn []string `json:"createdByIn,omitempty"` + CreatedByNotIn []string `json:"createdByNotIn,omitempty"` + CreatedByGt *string `json:"createdByGT,omitempty"` + CreatedByGte *string `json:"createdByGTE,omitempty"` + CreatedByLt *string `json:"createdByLT,omitempty"` + CreatedByLte *string `json:"createdByLTE,omitempty"` + CreatedByContains *string `json:"createdByContains,omitempty"` + CreatedByHasPrefix *string `json:"createdByHasPrefix,omitempty"` + CreatedByHasSuffix *string `json:"createdByHasSuffix,omitempty"` + CreatedByIsNil *bool `json:"createdByIsNil,omitempty"` + CreatedByNotNil *bool `json:"createdByNotNil,omitempty"` + CreatedByEqualFold *string `json:"createdByEqualFold,omitempty"` + CreatedByContainsFold *string `json:"createdByContainsFold,omitempty"` + // updated_by field predicates + UpdatedBy *string `json:"updatedBy,omitempty"` + UpdatedByNeq *string `json:"updatedByNEQ,omitempty"` + UpdatedByIn []string `json:"updatedByIn,omitempty"` + UpdatedByNotIn []string `json:"updatedByNotIn,omitempty"` + UpdatedByGt *string `json:"updatedByGT,omitempty"` + UpdatedByGte *string `json:"updatedByGTE,omitempty"` + UpdatedByLt *string `json:"updatedByLT,omitempty"` + UpdatedByLte *string `json:"updatedByLTE,omitempty"` + UpdatedByContains *string `json:"updatedByContains,omitempty"` + UpdatedByHasPrefix *string `json:"updatedByHasPrefix,omitempty"` + UpdatedByHasSuffix *string `json:"updatedByHasSuffix,omitempty"` + UpdatedByIsNil *bool `json:"updatedByIsNil,omitempty"` + UpdatedByNotNil *bool `json:"updatedByNotNil,omitempty"` + UpdatedByEqualFold *string `json:"updatedByEqualFold,omitempty"` + UpdatedByContainsFold *string `json:"updatedByContainsFold,omitempty"` + // deleted_at field predicates + DeletedAt *time.Time `json:"deletedAt,omitempty"` + DeletedAtNeq *time.Time `json:"deletedAtNEQ,omitempty"` + DeletedAtIn []*time.Time `json:"deletedAtIn,omitempty"` + DeletedAtNotIn []*time.Time `json:"deletedAtNotIn,omitempty"` + DeletedAtGt *time.Time `json:"deletedAtGT,omitempty"` + DeletedAtGte *time.Time `json:"deletedAtGTE,omitempty"` + DeletedAtLt *time.Time `json:"deletedAtLT,omitempty"` + DeletedAtLte *time.Time `json:"deletedAtLTE,omitempty"` + DeletedAtIsNil *bool `json:"deletedAtIsNil,omitempty"` + DeletedAtNotNil *bool `json:"deletedAtNotNil,omitempty"` + // deleted_by field predicates + DeletedBy *string `json:"deletedBy,omitempty"` + DeletedByNeq *string `json:"deletedByNEQ,omitempty"` + DeletedByIn []string `json:"deletedByIn,omitempty"` + DeletedByNotIn []string `json:"deletedByNotIn,omitempty"` + DeletedByGt *string `json:"deletedByGT,omitempty"` + DeletedByGte *string `json:"deletedByGTE,omitempty"` + DeletedByLt *string `json:"deletedByLT,omitempty"` + DeletedByLte *string `json:"deletedByLTE,omitempty"` + DeletedByContains *string `json:"deletedByContains,omitempty"` + DeletedByHasPrefix *string `json:"deletedByHasPrefix,omitempty"` + DeletedByHasSuffix *string `json:"deletedByHasSuffix,omitempty"` + DeletedByIsNil *bool `json:"deletedByIsNil,omitempty"` + DeletedByNotNil *bool `json:"deletedByNotNil,omitempty"` + DeletedByEqualFold *string `json:"deletedByEqualFold,omitempty"` + DeletedByContainsFold *string `json:"deletedByContainsFold,omitempty"` + // owner_id field predicates + OwnerID *string `json:"ownerID,omitempty"` + OwnerIdneq *string `json:"ownerIDNEQ,omitempty"` + OwnerIDIn []string `json:"ownerIDIn,omitempty"` + OwnerIDNotIn []string `json:"ownerIDNotIn,omitempty"` + OwnerIdgt *string `json:"ownerIDGT,omitempty"` + OwnerIdgte *string `json:"ownerIDGTE,omitempty"` + OwnerIdlt *string `json:"ownerIDLT,omitempty"` + OwnerIdlte *string `json:"ownerIDLTE,omitempty"` + OwnerIDContains *string `json:"ownerIDContains,omitempty"` + OwnerIDHasPrefix *string `json:"ownerIDHasPrefix,omitempty"` + OwnerIDHasSuffix *string `json:"ownerIDHasSuffix,omitempty"` + OwnerIDIsNil *bool `json:"ownerIDIsNil,omitempty"` + OwnerIDNotNil *bool `json:"ownerIDNotNil,omitempty"` + OwnerIDEqualFold *string `json:"ownerIDEqualFold,omitempty"` + OwnerIDContainsFold *string `json:"ownerIDContainsFold,omitempty"` + // stripe_subscription_id field predicates + StripeSubscriptionID *string `json:"stripeSubscriptionID,omitempty"` + StripeSubscriptionIdneq *string `json:"stripeSubscriptionIDNEQ,omitempty"` + StripeSubscriptionIDIn []string `json:"stripeSubscriptionIDIn,omitempty"` + StripeSubscriptionIDNotIn []string `json:"stripeSubscriptionIDNotIn,omitempty"` + StripeSubscriptionIdgt *string `json:"stripeSubscriptionIDGT,omitempty"` + StripeSubscriptionIdgte *string `json:"stripeSubscriptionIDGTE,omitempty"` + StripeSubscriptionIdlt *string `json:"stripeSubscriptionIDLT,omitempty"` + StripeSubscriptionIdlte *string `json:"stripeSubscriptionIDLTE,omitempty"` + StripeSubscriptionIDContains *string `json:"stripeSubscriptionIDContains,omitempty"` + StripeSubscriptionIDHasPrefix *string `json:"stripeSubscriptionIDHasPrefix,omitempty"` + StripeSubscriptionIDHasSuffix *string `json:"stripeSubscriptionIDHasSuffix,omitempty"` + StripeSubscriptionIDIsNil *bool `json:"stripeSubscriptionIDIsNil,omitempty"` + StripeSubscriptionIDNotNil *bool `json:"stripeSubscriptionIDNotNil,omitempty"` + StripeSubscriptionIDEqualFold *string `json:"stripeSubscriptionIDEqualFold,omitempty"` + StripeSubscriptionIDContainsFold *string `json:"stripeSubscriptionIDContainsFold,omitempty"` + // product_tier field predicates + ProductTier *string `json:"productTier,omitempty"` + ProductTierNeq *string `json:"productTierNEQ,omitempty"` + ProductTierIn []string `json:"productTierIn,omitempty"` + ProductTierNotIn []string `json:"productTierNotIn,omitempty"` + ProductTierGt *string `json:"productTierGT,omitempty"` + ProductTierGte *string `json:"productTierGTE,omitempty"` + ProductTierLt *string `json:"productTierLT,omitempty"` + ProductTierLte *string `json:"productTierLTE,omitempty"` + ProductTierContains *string `json:"productTierContains,omitempty"` + ProductTierHasPrefix *string `json:"productTierHasPrefix,omitempty"` + ProductTierHasSuffix *string `json:"productTierHasSuffix,omitempty"` + ProductTierIsNil *bool `json:"productTierIsNil,omitempty"` + ProductTierNotNil *bool `json:"productTierNotNil,omitempty"` + ProductTierEqualFold *string `json:"productTierEqualFold,omitempty"` + ProductTierContainsFold *string `json:"productTierContainsFold,omitempty"` + // stripe_product_tier_id field predicates + StripeProductTierID *string `json:"stripeProductTierID,omitempty"` + StripeProductTierIdneq *string `json:"stripeProductTierIDNEQ,omitempty"` + StripeProductTierIDIn []string `json:"stripeProductTierIDIn,omitempty"` + StripeProductTierIDNotIn []string `json:"stripeProductTierIDNotIn,omitempty"` + StripeProductTierIdgt *string `json:"stripeProductTierIDGT,omitempty"` + StripeProductTierIdgte *string `json:"stripeProductTierIDGTE,omitempty"` + StripeProductTierIdlt *string `json:"stripeProductTierIDLT,omitempty"` + StripeProductTierIdlte *string `json:"stripeProductTierIDLTE,omitempty"` + StripeProductTierIDContains *string `json:"stripeProductTierIDContains,omitempty"` + StripeProductTierIDHasPrefix *string `json:"stripeProductTierIDHasPrefix,omitempty"` + StripeProductTierIDHasSuffix *string `json:"stripeProductTierIDHasSuffix,omitempty"` + StripeProductTierIDIsNil *bool `json:"stripeProductTierIDIsNil,omitempty"` + StripeProductTierIDNotNil *bool `json:"stripeProductTierIDNotNil,omitempty"` + StripeProductTierIDEqualFold *string `json:"stripeProductTierIDEqualFold,omitempty"` + StripeProductTierIDContainsFold *string `json:"stripeProductTierIDContainsFold,omitempty"` + // stripe_subscription_status field predicates + StripeSubscriptionStatus *string `json:"stripeSubscriptionStatus,omitempty"` + StripeSubscriptionStatusNeq *string `json:"stripeSubscriptionStatusNEQ,omitempty"` + StripeSubscriptionStatusIn []string `json:"stripeSubscriptionStatusIn,omitempty"` + StripeSubscriptionStatusNotIn []string `json:"stripeSubscriptionStatusNotIn,omitempty"` + StripeSubscriptionStatusGt *string `json:"stripeSubscriptionStatusGT,omitempty"` + StripeSubscriptionStatusGte *string `json:"stripeSubscriptionStatusGTE,omitempty"` + StripeSubscriptionStatusLt *string `json:"stripeSubscriptionStatusLT,omitempty"` + StripeSubscriptionStatusLte *string `json:"stripeSubscriptionStatusLTE,omitempty"` + StripeSubscriptionStatusContains *string `json:"stripeSubscriptionStatusContains,omitempty"` + StripeSubscriptionStatusHasPrefix *string `json:"stripeSubscriptionStatusHasPrefix,omitempty"` + StripeSubscriptionStatusHasSuffix *string `json:"stripeSubscriptionStatusHasSuffix,omitempty"` + StripeSubscriptionStatusIsNil *bool `json:"stripeSubscriptionStatusIsNil,omitempty"` + StripeSubscriptionStatusNotNil *bool `json:"stripeSubscriptionStatusNotNil,omitempty"` + StripeSubscriptionStatusEqualFold *string `json:"stripeSubscriptionStatusEqualFold,omitempty"` + StripeSubscriptionStatusContainsFold *string `json:"stripeSubscriptionStatusContainsFold,omitempty"` + // active field predicates + Active *bool `json:"active,omitempty"` + ActiveNeq *bool `json:"activeNEQ,omitempty"` + // stripe_customer_id field predicates + StripeCustomerID *string `json:"stripeCustomerID,omitempty"` + StripeCustomerIdneq *string `json:"stripeCustomerIDNEQ,omitempty"` + StripeCustomerIDIn []string `json:"stripeCustomerIDIn,omitempty"` + StripeCustomerIDNotIn []string `json:"stripeCustomerIDNotIn,omitempty"` + StripeCustomerIdgt *string `json:"stripeCustomerIDGT,omitempty"` + StripeCustomerIdgte *string `json:"stripeCustomerIDGTE,omitempty"` + StripeCustomerIdlt *string `json:"stripeCustomerIDLT,omitempty"` + StripeCustomerIdlte *string `json:"stripeCustomerIDLTE,omitempty"` + StripeCustomerIDContains *string `json:"stripeCustomerIDContains,omitempty"` + StripeCustomerIDHasPrefix *string `json:"stripeCustomerIDHasPrefix,omitempty"` + StripeCustomerIDHasSuffix *string `json:"stripeCustomerIDHasSuffix,omitempty"` + StripeCustomerIDIsNil *bool `json:"stripeCustomerIDIsNil,omitempty"` + StripeCustomerIDNotNil *bool `json:"stripeCustomerIDNotNil,omitempty"` + StripeCustomerIDEqualFold *string `json:"stripeCustomerIDEqualFold,omitempty"` + StripeCustomerIDContainsFold *string `json:"stripeCustomerIDContainsFold,omitempty"` + // expires_at field predicates + ExpiresAt *time.Time `json:"expiresAt,omitempty"` + ExpiresAtNeq *time.Time `json:"expiresAtNEQ,omitempty"` + ExpiresAtIn []*time.Time `json:"expiresAtIn,omitempty"` + ExpiresAtNotIn []*time.Time `json:"expiresAtNotIn,omitempty"` + ExpiresAtGt *time.Time `json:"expiresAtGT,omitempty"` + ExpiresAtGte *time.Time `json:"expiresAtGTE,omitempty"` + ExpiresAtLt *time.Time `json:"expiresAtLT,omitempty"` + ExpiresAtLte *time.Time `json:"expiresAtLTE,omitempty"` + ExpiresAtIsNil *bool `json:"expiresAtIsNil,omitempty"` + ExpiresAtNotNil *bool `json:"expiresAtNotNil,omitempty"` + // owner edge predicates + HasOwner *bool `json:"hasOwner,omitempty"` + HasOwnerWith []*OrganizationWhereInput `json:"hasOwnerWith,omitempty"` +} + type Organization struct { ID string `json:"id"` CreatedAt *time.Time `json:"createdAt,omitempty"` @@ -14313,6 +14925,7 @@ type Organization struct { Setting *OrganizationSetting `json:"setting,omitempty"` Documentdata []*DocumentData `json:"documentdata,omitempty"` Entitlements []*Entitlement `json:"entitlements,omitempty"` + Orgsubscriptions []*OrgSubscription `json:"orgsubscriptions,omitempty"` OrganizationEntitlement []*Entitlement `json:"organizationEntitlement,omitempty"` PersonalAccessTokens []*PersonalAccessToken `json:"personalAccessTokens,omitempty"` APITokens []*APIToken `json:"apiTokens,omitempty"` @@ -15446,6 +16059,9 @@ type OrganizationWhereInput struct { // entitlements edge predicates HasEntitlements *bool `json:"hasEntitlements,omitempty"` HasEntitlementsWith []*EntitlementWhereInput `json:"hasEntitlementsWith,omitempty"` + // orgsubscriptions edge predicates + HasOrgsubscriptions *bool `json:"hasOrgsubscriptions,omitempty"` + HasOrgsubscriptionsWith []*OrgSubscriptionWhereInput `json:"hasOrgsubscriptionsWith,omitempty"` // organization_entitlement edge predicates HasOrganizationEntitlement *bool `json:"hasOrganizationEntitlement,omitempty"` HasOrganizationEntitlementWith []*EntitlementWhereInput `json:"hasOrganizationEntitlementWith,omitempty"` @@ -22110,6 +22726,41 @@ type UpdateOrgMembershipInput struct { ClearEvents *bool `json:"clearEvents,omitempty"` } +// UpdateOrgSubscriptionInput is used for update OrgSubscription object. +// Input was generated by ent. +type UpdateOrgSubscriptionInput struct { + // tags associated with the object + Tags []string `json:"tags,omitempty"` + AppendTags []string `json:"appendTags,omitempty"` + ClearTags *bool `json:"clearTags,omitempty"` + // the stripe subscription id + StripeSubscriptionID *string `json:"stripeSubscriptionID,omitempty"` + ClearStripeSubscriptionID *bool `json:"clearStripeSubscriptionID,omitempty"` + // the common name of the product tier the subscription is associated with, e.g. starter tier + ProductTier *string `json:"productTier,omitempty"` + ClearProductTier *bool `json:"clearProductTier,omitempty"` + // the product id that represents the tier in stripe + StripeProductTierID *string `json:"stripeProductTierID,omitempty"` + ClearStripeProductTierID *bool `json:"clearStripeProductTierID,omitempty"` + // the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + StripeSubscriptionStatus *string `json:"stripeSubscriptionStatus,omitempty"` + ClearStripeSubscriptionStatus *bool `json:"clearStripeSubscriptionStatus,omitempty"` + // indicates if the subscription is active + Active *bool `json:"active,omitempty"` + // the customer ID the subscription is associated to + StripeCustomerID *string `json:"stripeCustomerID,omitempty"` + ClearStripeCustomerID *bool `json:"clearStripeCustomerID,omitempty"` + // the time the subscription is set to expire; only populated if subscription is cancelled + ExpiresAt *time.Time `json:"expiresAt,omitempty"` + ClearExpiresAt *bool `json:"clearExpiresAt,omitempty"` + // the features associated with the subscription + Features []string `json:"features,omitempty"` + AppendFeatures []string `json:"appendFeatures,omitempty"` + ClearFeatures *bool `json:"clearFeatures,omitempty"` + OwnerID *string `json:"ownerID,omitempty"` + ClearOwner *bool `json:"clearOwner,omitempty"` +} + // UpdateOrganizationInput is used for update Organization object. // Input was generated by ent. type UpdateOrganizationInput struct { @@ -22171,6 +22822,9 @@ type UpdateOrganizationInput struct { AddEntitlementIDs []string `json:"addEntitlementIDs,omitempty"` RemoveEntitlementIDs []string `json:"removeEntitlementIDs,omitempty"` ClearEntitlements *bool `json:"clearEntitlements,omitempty"` + AddOrgsubscriptionIDs []string `json:"addOrgsubscriptionIDs,omitempty"` + RemoveOrgsubscriptionIDs []string `json:"removeOrgsubscriptionIDs,omitempty"` + ClearOrgsubscriptions *bool `json:"clearOrgsubscriptions,omitempty"` AddOrganizationEntitlementIDs []string `json:"addOrganizationEntitlementIDs,omitempty"` RemoveOrganizationEntitlementIDs []string `json:"removeOrganizationEntitlementIDs,omitempty"` ClearOrganizationEntitlement *bool `json:"clearOrganizationEntitlement,omitempty"` diff --git a/query/adminsearch.graphql b/query/adminsearch.graphql index ca8f8e00..0667b482 100644 --- a/query/adminsearch.graphql +++ b/query/adminsearch.graphql @@ -279,6 +279,20 @@ query AdminSearch($query: String!) { connectorData } } + ... on OrgSubscriptionSearchResult { + orgSubscriptions { + id + tags + deletedBy + ownerID + stripeSubscriptionID + productTier + stripeProductTierID + stripeSubscriptionStatus + stripeCustomerID + features + } + } ... on OrganizationSearchResult { organizations { id diff --git a/query/orgsubscription.graphql b/query/orgsubscription.graphql new file mode 100644 index 00000000..c9065964 --- /dev/null +++ b/query/orgsubscription.graphql @@ -0,0 +1,161 @@ +mutation CreateBulkCSVOrgSubscription($input: Upload!) { + createBulkCSVOrgSubscription(input: $input) { + orgSubscriptions { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } +} + +mutation CreateBulkOrgSubscription($input: [CreateOrgSubscriptionInput!]) { + createBulkOrgSubscription(input: $input) { + orgSubscriptions { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } +} + +mutation CreateOrgSubscription($input: CreateOrgSubscriptionInput!) { + createOrgSubscription(input: $input) { + orgSubscription { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } +} + +mutation DeleteOrgSubscription($deleteOrgSubscriptionId: ID!) { + deleteOrgSubscription(id: $deleteOrgSubscriptionId) { + deletedID + } +} + +query GetAllOrgSubscriptions { + orgSubscriptions { + edges { + node { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } + } +} + +query GetOrgSubscriptionByID($orgSubscriptionId: ID!) { + orgSubscription(id: $orgSubscriptionId) { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } +} + +query GetOrgSubscriptions($where: OrgSubscriptionWhereInput) { + orgSubscriptions(where: $where) { + edges { + node { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } + } +} + +mutation UpdateOrgSubscription($updateOrgSubscriptionId: ID!, $input: UpdateOrgSubscriptionInput!) { + updateOrgSubscription(id: $updateOrgSubscriptionId, input: $input) { + orgSubscription { + active + createdAt + createdBy + expiresAt + features + id + ownerID + productTier + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } +} diff --git a/query/orgsubscriptionhistory.graphql b/query/orgsubscriptionhistory.graphql new file mode 100644 index 00000000..474b4947 --- /dev/null +++ b/query/orgsubscriptionhistory.graphql @@ -0,0 +1,55 @@ + + +query GetAllOrgSubscriptionHistories { + orgSubscriptionHistories { + edges { + node { + active + createdAt + createdBy + expiresAt + features + historyTime + id + operation + ownerID + productTier + ref + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } + } +} + +query GetOrgSubscriptionHistories($where: OrgSubscriptionHistoryWhereInput) { + orgSubscriptionHistories(where: $where) { + edges { + node { + active + createdAt + createdBy + expiresAt + features + historyTime + id + operation + ownerID + productTier + ref + stripeCustomerID + stripeProductTierID + stripeSubscriptionID + stripeSubscriptionStatus + tags + updatedAt + updatedBy + } + } + } +} diff --git a/query/search.graphql b/query/search.graphql index dc952e3e..7224fff0 100644 --- a/query/search.graphql +++ b/query/search.graphql @@ -133,6 +133,12 @@ query GlobalSearch($query: String!) { tags } } + ... on OrgSubscriptionSearchResult { + orgSubscriptions { + id + tags + } + } ... on OrganizationSearchResult { organizations { displayName diff --git a/schema.graphql b/schema.graphql index f9677ce3..cc2c418b 100644 --- a/schema.graphql +++ b/schema.graphql @@ -4725,6 +4725,49 @@ input CreateOrgMembershipInput { eventIDs: [ID!] } """ +CreateOrgSubscriptionInput is used for create OrgSubscription object. +Input was generated by ent. +""" +input CreateOrgSubscriptionInput { + """ + tags associated with the object + """ + tags: [String!] + """ + the stripe subscription id + """ + stripeSubscriptionID: String + """ + the common name of the product tier the subscription is associated with, e.g. starter tier + """ + productTier: String + """ + the product id that represents the tier in stripe + """ + stripeProductTierID: String + """ + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + """ + stripeSubscriptionStatus: String + """ + indicates if the subscription is active + """ + active: Boolean + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + """ + the features associated with the subscription + """ + features: [String!] + ownerID: ID +} +""" CreateOrganizationInput is used for create Organization object. Input was generated by ent. """ @@ -4773,6 +4816,7 @@ input CreateOrganizationInput { settingID: ID documentdatumIDs: [ID!] entitlementIDs: [ID!] + orgsubscriptionIDs: [ID!] organizationEntitlementIDs: [ID!] personalAccessTokenIDs: [ID!] apiTokenIDs: [ID!] @@ -17017,6 +17061,56 @@ type Mutation { id: ID! ): OrgMembershipDeletePayload! """ + Create a new orgSubscription + """ + createOrgSubscription( + """ + values of the orgSubscription + """ + input: CreateOrgSubscriptionInput! + ): OrgSubscriptionCreatePayload! + """ + Create multiple new orgSubscriptions + """ + createBulkOrgSubscription( + """ + values of the orgSubscription + """ + input: [CreateOrgSubscriptionInput!] + ): OrgSubscriptionBulkCreatePayload! + """ + Create multiple new orgSubscriptions via file upload + """ + createBulkCSVOrgSubscription( + """ + csv file containing values of the orgSubscription + """ + input: Upload! + ): OrgSubscriptionBulkCreatePayload! + """ + Update an existing orgSubscription + """ + updateOrgSubscription( + """ + ID of the orgSubscription + """ + id: ID! + + """ + New values for the orgSubscription + """ + input: UpdateOrgSubscriptionInput! + ): OrgSubscriptionUpdatePayload! + """ + Delete an existing orgSubscription + """ + deleteOrgSubscription( + """ + ID of the orgSubscription + """ + id: ID! + ): OrgSubscriptionDeletePayload! + """ Create a new personalAccessToken """ createPersonalAccessToken( @@ -20341,7 +20435,7 @@ input OrgMembershipWhereInput { organizationID: String userID: String } -type Organization implements Node { +type OrgSubscription implements Node { id: ID! createdAt: Time updatedAt: Time @@ -20354,149 +20448,60 @@ type Organization implements Node { deletedAt: Time deletedBy: String """ - the name of the organization - """ - name: String! - """ - The organization's displayed 'friendly' name - """ - displayName: String! - """ - An optional description of the organization - """ - description: String - """ - orgs directly associated with a user - """ - personalOrg: Boolean - """ - URL of the user's remote avatar - """ - avatarRemoteURL: String - """ - Whether the organization has a dedicated database - """ - dedicatedDb: Boolean! - """ - groups that are allowed to create controls + the organization id that owns the object """ - controlCreators: [Group!] + ownerID: ID """ - groups that are allowed to create control_objectives + the stripe subscription id """ - controlObjectiveCreators: [Group!] + stripeSubscriptionID: String """ - groups that are allowed to create groups + the common name of the product tier the subscription is associated with, e.g. starter tier """ - groupCreators: [Group!] + productTier: String """ - groups that are allowed to create internal_policys + the product id that represents the tier in stripe """ - internalPolicyCreators: [Group!] + stripeProductTierID: String """ - groups that are allowed to create narratives + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status """ - narrativeCreators: [Group!] + stripeSubscriptionStatus: String """ - groups that are allowed to create procedures + indicates if the subscription is active """ - procedureCreators: [Group!] + active: Boolean! """ - groups that are allowed to create programs + the customer ID the subscription is associated to """ - programCreators: [Group!] + stripeCustomerID: String """ - groups that are allowed to create risks + the time the subscription is set to expire; only populated if subscription is cancelled """ - riskCreators: [Group!] + expiresAt: Time """ - groups that are allowed to create templates + the features associated with the subscription """ - templateCreators: [Group!] - parent: Organization - children( - """ - Returns the elements in the list that come after the specified cursor. - """ - after: Cursor - - """ - Returns the first _n_ elements from the list. - """ - first: Int - - """ - Returns the elements in the list that come before the specified cursor. - """ - before: Cursor - - """ - Returns the last _n_ elements from the list. - """ - last: Int - - """ - Ordering options for Organizations returned from the connection. - """ - orderBy: OrganizationOrder - - """ - Filtering options for Organizations returned from the connection. - """ - where: OrganizationWhereInput - ): OrganizationConnection! - groups: [Group!] - templates: [Template!] - integrations: [Integration!] - setting: OrganizationSetting - documentdata: [DocumentData!] - entitlements: [Entitlement!] - organizationEntitlement: [Entitlement!] - personalAccessTokens: [PersonalAccessToken!] - apiTokens: [APIToken!] - oauthprovider: [OauthProvider!] - users: [User!] - invites: [Invite!] - subscribers: [Subscriber!] - webhooks: [Webhook!] - events: [Event!] - secrets: [Hush!] - features: [Feature!] - files: [File!] - entitlementplans: [EntitlementPlan!] - entitlementplanfeatures: [EntitlementPlanFeature!] - entities: [Entity!] - entitytypes: [EntityType!] - contacts: [Contact!] - notes: [Note!] - tasks: [Task!] - programs: [Program!] - procedures: [Procedure!] - internalpolicies: [InternalPolicy!] - risks: [Risk!] - controlobjectives: [ControlObjective!] - narratives: [Narrative!] - controls: [Control!] - subcontrols: [Subcontrol!] - members: [OrgMembership!] + features: [String!] + owner: Organization } """ -Return response for createBulkOrganization mutation +Return response for createBulkOrgSubscription mutation """ -type OrganizationBulkCreatePayload { +type OrgSubscriptionBulkCreatePayload { """ - Created organizations + Created orgSubscriptions """ - organizations: [Organization!] + orgSubscriptions: [OrgSubscription!] } """ A connection to a list of items. """ -type OrganizationConnection { +type OrgSubscriptionConnection { """ A list of edges. """ - edges: [OrganizationEdge] + edges: [OrgSubscriptionEdge] """ Information to aid in pagination. """ @@ -20507,41 +20512,41 @@ type OrganizationConnection { totalCount: Int! } """ -Return response for createOrganization mutation +Return response for createOrgSubscription mutation """ -type OrganizationCreatePayload { +type OrgSubscriptionCreatePayload { """ - Created organization + Created orgSubscription """ - organization: Organization! + orgSubscription: OrgSubscription! } """ -Return response for deleteOrganization mutation +Return response for deleteOrgSubscription mutation """ -type OrganizationDeletePayload { +type OrgSubscriptionDeletePayload { """ - Deleted organization ID + Deleted orgSubscription ID """ deletedID: ID! } """ An edge in a connection. """ -type OrganizationEdge { +type OrgSubscriptionEdge { """ The item at the end of the edge. """ - node: Organization + node: OrgSubscription """ A cursor for use in pagination. """ cursor: Cursor! } -type OrganizationHistory implements Node { +type OrgSubscriptionHistory implements Node { id: ID! historyTime: Time! ref: String - operation: OrganizationHistoryOpType! + operation: OrgSubscriptionHistoryOpType! createdAt: Time updatedAt: Time createdBy: String @@ -20553,38 +20558,50 @@ type OrganizationHistory implements Node { deletedAt: Time deletedBy: String """ - the name of the organization + the organization id that owns the object """ - name: String! + ownerID: String """ - The organization's displayed 'friendly' name + the stripe subscription id """ - displayName: String! + stripeSubscriptionID: String """ - An optional description of the organization + the common name of the product tier the subscription is associated with, e.g. starter tier """ - description: String + productTier: String """ - orgs directly associated with a user + the product id that represents the tier in stripe """ - personalOrg: Boolean + stripeProductTierID: String """ - URL of the user's remote avatar + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status """ - avatarRemoteURL: String + stripeSubscriptionStatus: String """ - Whether the organization has a dedicated database + indicates if the subscription is active """ - dedicatedDb: Boolean! + active: Boolean! + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + """ + the features associated with the subscription + """ + features: [String!] } """ A connection to a list of items. """ -type OrganizationHistoryConnection { +type OrgSubscriptionHistoryConnection { """ A list of edges. """ - edges: [OrganizationHistoryEdge] + edges: [OrgSubscriptionHistoryEdge] """ Information to aid in pagination. """ @@ -20597,52 +20614,32 @@ type OrganizationHistoryConnection { """ An edge in a connection. """ -type OrganizationHistoryEdge { +type OrgSubscriptionHistoryEdge { """ The item at the end of the edge. """ - node: OrganizationHistory + node: OrgSubscriptionHistory """ A cursor for use in pagination. """ cursor: Cursor! } """ -OrganizationHistoryOpType is enum for the field operation +OrgSubscriptionHistoryOpType is enum for the field operation """ -enum OrganizationHistoryOpType @goModel(model: "github.com/theopenlane/entx/history.OpType") { +enum OrgSubscriptionHistoryOpType @goModel(model: "github.com/theopenlane/entx/history.OpType") { INSERT UPDATE DELETE } """ -Ordering options for OrganizationHistory connections -""" -input OrganizationHistoryOrder { - """ - The ordering direction. - """ - direction: OrderDirection! = ASC - """ - The field by which to order OrganizationHistories. - """ - field: OrganizationHistoryOrderField! -} -""" -Properties by which OrganizationHistory connections can be ordered. -""" -enum OrganizationHistoryOrderField { - name - display_name -} -""" -OrganizationHistoryWhereInput is used for filtering OrganizationHistory objects. +OrgSubscriptionHistoryWhereInput is used for filtering OrgSubscriptionHistory objects. Input was generated by ent. """ -input OrganizationHistoryWhereInput { - not: OrganizationHistoryWhereInput - and: [OrganizationHistoryWhereInput!] - or: [OrganizationHistoryWhereInput!] +input OrgSubscriptionHistoryWhereInput { + not: OrgSubscriptionHistoryWhereInput + and: [OrgSubscriptionHistoryWhereInput!] + or: [OrgSubscriptionHistoryWhereInput!] """ id field predicates """ @@ -20688,10 +20685,10 @@ input OrganizationHistoryWhereInput { """ operation field predicates """ - operation: OrganizationHistoryOpType - operationNEQ: OrganizationHistoryOpType - operationIn: [OrganizationHistoryOpType!] - operationNotIn: [OrganizationHistoryOpType!] + operation: OrgSubscriptionHistoryOpType + operationNEQ: OrgSubscriptionHistoryOpType + operationIn: [OrgSubscriptionHistoryOpType!] + operationNotIn: [OrgSubscriptionHistoryOpType!] """ created_at field predicates """ @@ -20786,21 +20783,851 @@ input OrganizationHistoryWhereInput { deletedByEqualFold: String deletedByContainsFold: String """ - display_name field predicates + owner_id field predicates """ - displayName: String - displayNameNEQ: String - displayNameIn: [String!] - displayNameNotIn: [String!] - displayNameGT: String - displayNameGTE: String - displayNameLT: String - displayNameLTE: String - displayNameContains: String - displayNameHasPrefix: String - displayNameHasSuffix: String - displayNameEqualFold: String - displayNameContainsFold: String + ownerID: String + ownerIDNEQ: String + ownerIDIn: [String!] + ownerIDNotIn: [String!] + ownerIDGT: String + ownerIDGTE: String + ownerIDLT: String + ownerIDLTE: String + ownerIDContains: String + ownerIDHasPrefix: String + ownerIDHasSuffix: String + ownerIDIsNil: Boolean + ownerIDNotNil: Boolean + ownerIDEqualFold: String + ownerIDContainsFold: String + """ + stripe_subscription_id field predicates + """ + stripeSubscriptionID: String + stripeSubscriptionIDNEQ: String + stripeSubscriptionIDIn: [String!] + stripeSubscriptionIDNotIn: [String!] + stripeSubscriptionIDGT: String + stripeSubscriptionIDGTE: String + stripeSubscriptionIDLT: String + stripeSubscriptionIDLTE: String + stripeSubscriptionIDContains: String + stripeSubscriptionIDHasPrefix: String + stripeSubscriptionIDHasSuffix: String + stripeSubscriptionIDIsNil: Boolean + stripeSubscriptionIDNotNil: Boolean + stripeSubscriptionIDEqualFold: String + stripeSubscriptionIDContainsFold: String + """ + product_tier field predicates + """ + productTier: String + productTierNEQ: String + productTierIn: [String!] + productTierNotIn: [String!] + productTierGT: String + productTierGTE: String + productTierLT: String + productTierLTE: String + productTierContains: String + productTierHasPrefix: String + productTierHasSuffix: String + productTierIsNil: Boolean + productTierNotNil: Boolean + productTierEqualFold: String + productTierContainsFold: String + """ + stripe_product_tier_id field predicates + """ + stripeProductTierID: String + stripeProductTierIDNEQ: String + stripeProductTierIDIn: [String!] + stripeProductTierIDNotIn: [String!] + stripeProductTierIDGT: String + stripeProductTierIDGTE: String + stripeProductTierIDLT: String + stripeProductTierIDLTE: String + stripeProductTierIDContains: String + stripeProductTierIDHasPrefix: String + stripeProductTierIDHasSuffix: String + stripeProductTierIDIsNil: Boolean + stripeProductTierIDNotNil: Boolean + stripeProductTierIDEqualFold: String + stripeProductTierIDContainsFold: String + """ + stripe_subscription_status field predicates + """ + stripeSubscriptionStatus: String + stripeSubscriptionStatusNEQ: String + stripeSubscriptionStatusIn: [String!] + stripeSubscriptionStatusNotIn: [String!] + stripeSubscriptionStatusGT: String + stripeSubscriptionStatusGTE: String + stripeSubscriptionStatusLT: String + stripeSubscriptionStatusLTE: String + stripeSubscriptionStatusContains: String + stripeSubscriptionStatusHasPrefix: String + stripeSubscriptionStatusHasSuffix: String + stripeSubscriptionStatusIsNil: Boolean + stripeSubscriptionStatusNotNil: Boolean + stripeSubscriptionStatusEqualFold: String + stripeSubscriptionStatusContainsFold: String + """ + active field predicates + """ + active: Boolean + activeNEQ: Boolean + """ + stripe_customer_id field predicates + """ + stripeCustomerID: String + stripeCustomerIDNEQ: String + stripeCustomerIDIn: [String!] + stripeCustomerIDNotIn: [String!] + stripeCustomerIDGT: String + stripeCustomerIDGTE: String + stripeCustomerIDLT: String + stripeCustomerIDLTE: String + stripeCustomerIDContains: String + stripeCustomerIDHasPrefix: String + stripeCustomerIDHasSuffix: String + stripeCustomerIDIsNil: Boolean + stripeCustomerIDNotNil: Boolean + stripeCustomerIDEqualFold: String + stripeCustomerIDContainsFold: String + """ + expires_at field predicates + """ + expiresAt: Time + expiresAtNEQ: Time + expiresAtIn: [Time!] + expiresAtNotIn: [Time!] + expiresAtGT: Time + expiresAtGTE: Time + expiresAtLT: Time + expiresAtLTE: Time + expiresAtIsNil: Boolean + expiresAtNotNil: Boolean +} +type OrgSubscriptionSearchResult { + orgSubscriptions: [OrgSubscription!] +} +""" +Return response for updateOrgSubscription mutation +""" +type OrgSubscriptionUpdatePayload { + """ + Updated orgSubscription + """ + orgSubscription: OrgSubscription! +} +""" +OrgSubscriptionWhereInput is used for filtering OrgSubscription objects. +Input was generated by ent. +""" +input OrgSubscriptionWhereInput { + not: OrgSubscriptionWhereInput + and: [OrgSubscriptionWhereInput!] + or: [OrgSubscriptionWhereInput!] + """ + id field predicates + """ + id: ID + idNEQ: ID + idIn: [ID!] + idNotIn: [ID!] + idGT: ID + idGTE: ID + idLT: ID + idLTE: ID + idEqualFold: ID + idContainsFold: ID + """ + created_at field predicates + """ + createdAt: Time + createdAtNEQ: Time + createdAtIn: [Time!] + createdAtNotIn: [Time!] + createdAtGT: Time + createdAtGTE: Time + createdAtLT: Time + createdAtLTE: Time + createdAtIsNil: Boolean + createdAtNotNil: Boolean + """ + updated_at field predicates + """ + updatedAt: Time + updatedAtNEQ: Time + updatedAtIn: [Time!] + updatedAtNotIn: [Time!] + updatedAtGT: Time + updatedAtGTE: Time + updatedAtLT: Time + updatedAtLTE: Time + updatedAtIsNil: Boolean + updatedAtNotNil: Boolean + """ + created_by field predicates + """ + createdBy: String + createdByNEQ: String + createdByIn: [String!] + createdByNotIn: [String!] + createdByGT: String + createdByGTE: String + createdByLT: String + createdByLTE: String + createdByContains: String + createdByHasPrefix: String + createdByHasSuffix: String + createdByIsNil: Boolean + createdByNotNil: Boolean + createdByEqualFold: String + createdByContainsFold: String + """ + updated_by field predicates + """ + updatedBy: String + updatedByNEQ: String + updatedByIn: [String!] + updatedByNotIn: [String!] + updatedByGT: String + updatedByGTE: String + updatedByLT: String + updatedByLTE: String + updatedByContains: String + updatedByHasPrefix: String + updatedByHasSuffix: String + updatedByIsNil: Boolean + updatedByNotNil: Boolean + updatedByEqualFold: String + updatedByContainsFold: String + """ + deleted_at field predicates + """ + deletedAt: Time + deletedAtNEQ: Time + deletedAtIn: [Time!] + deletedAtNotIn: [Time!] + deletedAtGT: Time + deletedAtGTE: Time + deletedAtLT: Time + deletedAtLTE: Time + deletedAtIsNil: Boolean + deletedAtNotNil: Boolean + """ + deleted_by field predicates + """ + deletedBy: String + deletedByNEQ: String + deletedByIn: [String!] + deletedByNotIn: [String!] + deletedByGT: String + deletedByGTE: String + deletedByLT: String + deletedByLTE: String + deletedByContains: String + deletedByHasPrefix: String + deletedByHasSuffix: String + deletedByIsNil: Boolean + deletedByNotNil: Boolean + deletedByEqualFold: String + deletedByContainsFold: String + """ + owner_id field predicates + """ + ownerID: ID + ownerIDNEQ: ID + ownerIDIn: [ID!] + ownerIDNotIn: [ID!] + ownerIDGT: ID + ownerIDGTE: ID + ownerIDLT: ID + ownerIDLTE: ID + ownerIDContains: ID + ownerIDHasPrefix: ID + ownerIDHasSuffix: ID + ownerIDIsNil: Boolean + ownerIDNotNil: Boolean + ownerIDEqualFold: ID + ownerIDContainsFold: ID + """ + stripe_subscription_id field predicates + """ + stripeSubscriptionID: String + stripeSubscriptionIDNEQ: String + stripeSubscriptionIDIn: [String!] + stripeSubscriptionIDNotIn: [String!] + stripeSubscriptionIDGT: String + stripeSubscriptionIDGTE: String + stripeSubscriptionIDLT: String + stripeSubscriptionIDLTE: String + stripeSubscriptionIDContains: String + stripeSubscriptionIDHasPrefix: String + stripeSubscriptionIDHasSuffix: String + stripeSubscriptionIDIsNil: Boolean + stripeSubscriptionIDNotNil: Boolean + stripeSubscriptionIDEqualFold: String + stripeSubscriptionIDContainsFold: String + """ + product_tier field predicates + """ + productTier: String + productTierNEQ: String + productTierIn: [String!] + productTierNotIn: [String!] + productTierGT: String + productTierGTE: String + productTierLT: String + productTierLTE: String + productTierContains: String + productTierHasPrefix: String + productTierHasSuffix: String + productTierIsNil: Boolean + productTierNotNil: Boolean + productTierEqualFold: String + productTierContainsFold: String + """ + stripe_product_tier_id field predicates + """ + stripeProductTierID: String + stripeProductTierIDNEQ: String + stripeProductTierIDIn: [String!] + stripeProductTierIDNotIn: [String!] + stripeProductTierIDGT: String + stripeProductTierIDGTE: String + stripeProductTierIDLT: String + stripeProductTierIDLTE: String + stripeProductTierIDContains: String + stripeProductTierIDHasPrefix: String + stripeProductTierIDHasSuffix: String + stripeProductTierIDIsNil: Boolean + stripeProductTierIDNotNil: Boolean + stripeProductTierIDEqualFold: String + stripeProductTierIDContainsFold: String + """ + stripe_subscription_status field predicates + """ + stripeSubscriptionStatus: String + stripeSubscriptionStatusNEQ: String + stripeSubscriptionStatusIn: [String!] + stripeSubscriptionStatusNotIn: [String!] + stripeSubscriptionStatusGT: String + stripeSubscriptionStatusGTE: String + stripeSubscriptionStatusLT: String + stripeSubscriptionStatusLTE: String + stripeSubscriptionStatusContains: String + stripeSubscriptionStatusHasPrefix: String + stripeSubscriptionStatusHasSuffix: String + stripeSubscriptionStatusIsNil: Boolean + stripeSubscriptionStatusNotNil: Boolean + stripeSubscriptionStatusEqualFold: String + stripeSubscriptionStatusContainsFold: String + """ + active field predicates + """ + active: Boolean + activeNEQ: Boolean + """ + stripe_customer_id field predicates + """ + stripeCustomerID: String + stripeCustomerIDNEQ: String + stripeCustomerIDIn: [String!] + stripeCustomerIDNotIn: [String!] + stripeCustomerIDGT: String + stripeCustomerIDGTE: String + stripeCustomerIDLT: String + stripeCustomerIDLTE: String + stripeCustomerIDContains: String + stripeCustomerIDHasPrefix: String + stripeCustomerIDHasSuffix: String + stripeCustomerIDIsNil: Boolean + stripeCustomerIDNotNil: Boolean + stripeCustomerIDEqualFold: String + stripeCustomerIDContainsFold: String + """ + expires_at field predicates + """ + expiresAt: Time + expiresAtNEQ: Time + expiresAtIn: [Time!] + expiresAtNotIn: [Time!] + expiresAtGT: Time + expiresAtGTE: Time + expiresAtLT: Time + expiresAtLTE: Time + expiresAtIsNil: Boolean + expiresAtNotNil: Boolean + """ + owner edge predicates + """ + hasOwner: Boolean + hasOwnerWith: [OrganizationWhereInput!] +} +type Organization implements Node { + id: ID! + createdAt: Time + updatedAt: Time + createdBy: String + updatedBy: String + """ + tags associated with the object + """ + tags: [String!] + deletedAt: Time + deletedBy: String + """ + the name of the organization + """ + name: String! + """ + The organization's displayed 'friendly' name + """ + displayName: String! + """ + An optional description of the organization + """ + description: String + """ + orgs directly associated with a user + """ + personalOrg: Boolean + """ + URL of the user's remote avatar + """ + avatarRemoteURL: String + """ + Whether the organization has a dedicated database + """ + dedicatedDb: Boolean! + """ + groups that are allowed to create controls + """ + controlCreators: [Group!] + """ + groups that are allowed to create control_objectives + """ + controlObjectiveCreators: [Group!] + """ + groups that are allowed to create groups + """ + groupCreators: [Group!] + """ + groups that are allowed to create internal_policys + """ + internalPolicyCreators: [Group!] + """ + groups that are allowed to create narratives + """ + narrativeCreators: [Group!] + """ + groups that are allowed to create procedures + """ + procedureCreators: [Group!] + """ + groups that are allowed to create programs + """ + programCreators: [Group!] + """ + groups that are allowed to create risks + """ + riskCreators: [Group!] + """ + groups that are allowed to create templates + """ + templateCreators: [Group!] + parent: Organization + children( + """ + Returns the elements in the list that come after the specified cursor. + """ + after: Cursor + + """ + Returns the first _n_ elements from the list. + """ + first: Int + + """ + Returns the elements in the list that come before the specified cursor. + """ + before: Cursor + + """ + Returns the last _n_ elements from the list. + """ + last: Int + + """ + Ordering options for Organizations returned from the connection. + """ + orderBy: OrganizationOrder + + """ + Filtering options for Organizations returned from the connection. + """ + where: OrganizationWhereInput + ): OrganizationConnection! + groups: [Group!] + templates: [Template!] + integrations: [Integration!] + setting: OrganizationSetting + documentdata: [DocumentData!] + entitlements: [Entitlement!] + orgsubscriptions: [OrgSubscription!] + organizationEntitlement: [Entitlement!] + personalAccessTokens: [PersonalAccessToken!] + apiTokens: [APIToken!] + oauthprovider: [OauthProvider!] + users: [User!] + invites: [Invite!] + subscribers: [Subscriber!] + webhooks: [Webhook!] + events: [Event!] + secrets: [Hush!] + features: [Feature!] + files: [File!] + entitlementplans: [EntitlementPlan!] + entitlementplanfeatures: [EntitlementPlanFeature!] + entities: [Entity!] + entitytypes: [EntityType!] + contacts: [Contact!] + notes: [Note!] + tasks: [Task!] + programs: [Program!] + procedures: [Procedure!] + internalpolicies: [InternalPolicy!] + risks: [Risk!] + controlobjectives: [ControlObjective!] + narratives: [Narrative!] + controls: [Control!] + subcontrols: [Subcontrol!] + members: [OrgMembership!] +} +""" +Return response for createBulkOrganization mutation +""" +type OrganizationBulkCreatePayload { + """ + Created organizations + """ + organizations: [Organization!] +} +""" +A connection to a list of items. +""" +type OrganizationConnection { + """ + A list of edges. + """ + edges: [OrganizationEdge] + """ + Information to aid in pagination. + """ + pageInfo: PageInfo! + """ + Identifies the total count of items in the connection. + """ + totalCount: Int! +} +""" +Return response for createOrganization mutation +""" +type OrganizationCreatePayload { + """ + Created organization + """ + organization: Organization! +} +""" +Return response for deleteOrganization mutation +""" +type OrganizationDeletePayload { + """ + Deleted organization ID + """ + deletedID: ID! +} +""" +An edge in a connection. +""" +type OrganizationEdge { + """ + The item at the end of the edge. + """ + node: Organization + """ + A cursor for use in pagination. + """ + cursor: Cursor! +} +type OrganizationHistory implements Node { + id: ID! + historyTime: Time! + ref: String + operation: OrganizationHistoryOpType! + createdAt: Time + updatedAt: Time + createdBy: String + updatedBy: String + """ + tags associated with the object + """ + tags: [String!] + deletedAt: Time + deletedBy: String + """ + the name of the organization + """ + name: String! + """ + The organization's displayed 'friendly' name + """ + displayName: String! + """ + An optional description of the organization + """ + description: String + """ + orgs directly associated with a user + """ + personalOrg: Boolean + """ + URL of the user's remote avatar + """ + avatarRemoteURL: String + """ + Whether the organization has a dedicated database + """ + dedicatedDb: Boolean! +} +""" +A connection to a list of items. +""" +type OrganizationHistoryConnection { + """ + A list of edges. + """ + edges: [OrganizationHistoryEdge] + """ + Information to aid in pagination. + """ + pageInfo: PageInfo! + """ + Identifies the total count of items in the connection. + """ + totalCount: Int! +} +""" +An edge in a connection. +""" +type OrganizationHistoryEdge { + """ + The item at the end of the edge. + """ + node: OrganizationHistory + """ + A cursor for use in pagination. + """ + cursor: Cursor! +} +""" +OrganizationHistoryOpType is enum for the field operation +""" +enum OrganizationHistoryOpType @goModel(model: "github.com/theopenlane/entx/history.OpType") { + INSERT + UPDATE + DELETE +} +""" +Ordering options for OrganizationHistory connections +""" +input OrganizationHistoryOrder { + """ + The ordering direction. + """ + direction: OrderDirection! = ASC + """ + The field by which to order OrganizationHistories. + """ + field: OrganizationHistoryOrderField! +} +""" +Properties by which OrganizationHistory connections can be ordered. +""" +enum OrganizationHistoryOrderField { + name + display_name +} +""" +OrganizationHistoryWhereInput is used for filtering OrganizationHistory objects. +Input was generated by ent. +""" +input OrganizationHistoryWhereInput { + not: OrganizationHistoryWhereInput + and: [OrganizationHistoryWhereInput!] + or: [OrganizationHistoryWhereInput!] + """ + id field predicates + """ + id: ID + idNEQ: ID + idIn: [ID!] + idNotIn: [ID!] + idGT: ID + idGTE: ID + idLT: ID + idLTE: ID + idEqualFold: ID + idContainsFold: ID + """ + history_time field predicates + """ + historyTime: Time + historyTimeNEQ: Time + historyTimeIn: [Time!] + historyTimeNotIn: [Time!] + historyTimeGT: Time + historyTimeGTE: Time + historyTimeLT: Time + historyTimeLTE: Time + """ + ref field predicates + """ + ref: String + refNEQ: String + refIn: [String!] + refNotIn: [String!] + refGT: String + refGTE: String + refLT: String + refLTE: String + refContains: String + refHasPrefix: String + refHasSuffix: String + refIsNil: Boolean + refNotNil: Boolean + refEqualFold: String + refContainsFold: String + """ + operation field predicates + """ + operation: OrganizationHistoryOpType + operationNEQ: OrganizationHistoryOpType + operationIn: [OrganizationHistoryOpType!] + operationNotIn: [OrganizationHistoryOpType!] + """ + created_at field predicates + """ + createdAt: Time + createdAtNEQ: Time + createdAtIn: [Time!] + createdAtNotIn: [Time!] + createdAtGT: Time + createdAtGTE: Time + createdAtLT: Time + createdAtLTE: Time + createdAtIsNil: Boolean + createdAtNotNil: Boolean + """ + updated_at field predicates + """ + updatedAt: Time + updatedAtNEQ: Time + updatedAtIn: [Time!] + updatedAtNotIn: [Time!] + updatedAtGT: Time + updatedAtGTE: Time + updatedAtLT: Time + updatedAtLTE: Time + updatedAtIsNil: Boolean + updatedAtNotNil: Boolean + """ + created_by field predicates + """ + createdBy: String + createdByNEQ: String + createdByIn: [String!] + createdByNotIn: [String!] + createdByGT: String + createdByGTE: String + createdByLT: String + createdByLTE: String + createdByContains: String + createdByHasPrefix: String + createdByHasSuffix: String + createdByIsNil: Boolean + createdByNotNil: Boolean + createdByEqualFold: String + createdByContainsFold: String + """ + updated_by field predicates + """ + updatedBy: String + updatedByNEQ: String + updatedByIn: [String!] + updatedByNotIn: [String!] + updatedByGT: String + updatedByGTE: String + updatedByLT: String + updatedByLTE: String + updatedByContains: String + updatedByHasPrefix: String + updatedByHasSuffix: String + updatedByIsNil: Boolean + updatedByNotNil: Boolean + updatedByEqualFold: String + updatedByContainsFold: String + """ + deleted_at field predicates + """ + deletedAt: Time + deletedAtNEQ: Time + deletedAtIn: [Time!] + deletedAtNotIn: [Time!] + deletedAtGT: Time + deletedAtGTE: Time + deletedAtLT: Time + deletedAtLTE: Time + deletedAtIsNil: Boolean + deletedAtNotNil: Boolean + """ + deleted_by field predicates + """ + deletedBy: String + deletedByNEQ: String + deletedByIn: [String!] + deletedByNotIn: [String!] + deletedByGT: String + deletedByGTE: String + deletedByLT: String + deletedByLTE: String + deletedByContains: String + deletedByHasPrefix: String + deletedByHasSuffix: String + deletedByIsNil: Boolean + deletedByNotNil: Boolean + deletedByEqualFold: String + deletedByContainsFold: String + """ + display_name field predicates + """ + displayName: String + displayNameNEQ: String + displayNameIn: [String!] + displayNameNotIn: [String!] + displayNameGT: String + displayNameGTE: String + displayNameLT: String + displayNameLTE: String + displayNameContains: String + displayNameHasPrefix: String + displayNameHasSuffix: String + displayNameEqualFold: String + displayNameContainsFold: String """ parent_organization_id field predicates """ @@ -21908,6 +22735,11 @@ input OrganizationWhereInput { hasEntitlements: Boolean hasEntitlementsWith: [EntitlementWhereInput!] """ + orgsubscriptions edge predicates + """ + hasOrgsubscriptions: Boolean + hasOrgsubscriptionsWith: [OrgSubscriptionWhereInput!] + """ organization_entitlement edge predicates """ hasOrganizationEntitlement: Boolean @@ -25825,6 +26657,58 @@ type Query { """ where: OrgMembershipHistoryWhereInput ): OrgMembershipHistoryConnection! + orgSubscriptions( + """ + Returns the elements in the list that come after the specified cursor. + """ + after: Cursor + + """ + Returns the first _n_ elements from the list. + """ + first: Int + + """ + Returns the elements in the list that come before the specified cursor. + """ + before: Cursor + + """ + Returns the last _n_ elements from the list. + """ + last: Int + + """ + Filtering options for OrgSubscriptions returned from the connection. + """ + where: OrgSubscriptionWhereInput + ): OrgSubscriptionConnection! + orgSubscriptionHistories( + """ + Returns the elements in the list that come after the specified cursor. + """ + after: Cursor + + """ + Returns the first _n_ elements from the list. + """ + first: Int + + """ + Returns the elements in the list that come before the specified cursor. + """ + before: Cursor + + """ + Returns the last _n_ elements from the list. + """ + last: Int + + """ + Filtering options for OrgSubscriptionHistories returned from the connection. + """ + where: OrgSubscriptionHistoryWhereInput + ): OrgSubscriptionHistoryConnection! organizations( """ Returns the elements in the list that come after the specified cursor. @@ -26818,6 +27702,15 @@ type Query { query: String! ): OhAuthTooTokenSearchResult """ + Search across OrgSubscription objects + """ + adminOrgSubscriptionSearch( + """ + Search query + """ + query: String! + ): OrgSubscriptionSearchResult + """ Search across Organization objects """ adminOrganizationSearch( @@ -27213,6 +28106,15 @@ type Query { id: ID! ): OrgMembership! """ + Look up orgSubscription by ID + """ + orgSubscription( + """ + ID of the orgSubscription + """ + id: ID! + ): OrgSubscription! + """ Look up personalAccessToken by ID """ personalAccessToken( @@ -27447,6 +28349,15 @@ type Query { query: String! ): OhAuthTooTokenSearchResult """ + Search across OrgSubscription objects + """ + orgSubscriptionSearch( + """ + Search query + """ + query: String! + ): OrgSubscriptionSearchResult + """ Search across Organization objects """ organizationSearch( @@ -28576,7 +29487,7 @@ input RiskWhereInput { hasPrograms: Boolean hasProgramsWith: [ProgramWhereInput!] } -union SearchResult = APITokenSearchResult | ActionPlanSearchResult | ContactSearchResult | ControlSearchResult | ControlObjectiveSearchResult | DocumentDataSearchResult | EntitlementSearchResult | EntitlementPlanSearchResult | EntitlementPlanFeatureSearchResult | EntitySearchResult | EntityTypeSearchResult | EventSearchResult | FeatureSearchResult | FileSearchResult | GroupSearchResult | GroupSettingSearchResult | IntegrationSearchResult | InternalPolicySearchResult | NarrativeSearchResult | OauthProviderSearchResult | OhAuthTooTokenSearchResult | OrganizationSearchResult | OrganizationSettingSearchResult | PersonalAccessTokenSearchResult | ProcedureSearchResult | ProgramSearchResult | RiskSearchResult | StandardSearchResult | SubcontrolSearchResult | SubscriberSearchResult | TFASettingSearchResult | TaskSearchResult | TemplateSearchResult | UserSearchResult | UserSettingSearchResult | WebhookSearchResult +union SearchResult = APITokenSearchResult | ActionPlanSearchResult | ContactSearchResult | ControlSearchResult | ControlObjectiveSearchResult | DocumentDataSearchResult | EntitlementSearchResult | EntitlementPlanSearchResult | EntitlementPlanFeatureSearchResult | EntitySearchResult | EntityTypeSearchResult | EventSearchResult | FeatureSearchResult | FileSearchResult | GroupSearchResult | GroupSettingSearchResult | IntegrationSearchResult | InternalPolicySearchResult | NarrativeSearchResult | OauthProviderSearchResult | OhAuthTooTokenSearchResult | OrgSubscriptionSearchResult | OrganizationSearchResult | OrganizationSettingSearchResult | PersonalAccessTokenSearchResult | ProcedureSearchResult | ProgramSearchResult | RiskSearchResult | StandardSearchResult | SubcontrolSearchResult | SubscriberSearchResult | TFASettingSearchResult | TaskSearchResult | TemplateSearchResult | UserSearchResult | UserSettingSearchResult | WebhookSearchResult type SearchResultConnection { page: PageInfo! nodes: [SearchResult!]! @@ -33696,6 +34607,60 @@ input UpdateOrgMembershipInput { clearEvents: Boolean } """ +UpdateOrgSubscriptionInput is used for update OrgSubscription object. +Input was generated by ent. +""" +input UpdateOrgSubscriptionInput { + """ + tags associated with the object + """ + tags: [String!] + appendTags: [String!] + clearTags: Boolean + """ + the stripe subscription id + """ + stripeSubscriptionID: String + clearStripeSubscriptionID: Boolean + """ + the common name of the product tier the subscription is associated with, e.g. starter tier + """ + productTier: String + clearProductTier: Boolean + """ + the product id that represents the tier in stripe + """ + stripeProductTierID: String + clearStripeProductTierID: Boolean + """ + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + """ + stripeSubscriptionStatus: String + clearStripeSubscriptionStatus: Boolean + """ + indicates if the subscription is active + """ + active: Boolean + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + clearStripeCustomerID: Boolean + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + clearExpiresAt: Boolean + """ + the features associated with the subscription + """ + features: [String!] + appendFeatures: [String!] + clearFeatures: Boolean + ownerID: ID + clearOwner: Boolean +} +""" UpdateOrganizationInput is used for update Organization object. Input was generated by ent. """ @@ -33768,6 +34733,9 @@ input UpdateOrganizationInput { addEntitlementIDs: [ID!] removeEntitlementIDs: [ID!] clearEntitlements: Boolean + addOrgsubscriptionIDs: [ID!] + removeOrgsubscriptionIDs: [ID!] + clearOrgsubscriptions: Boolean addOrganizationEntitlementIDs: [ID!] removeOrganizationEntitlementIDs: [ID!] clearOrganizationEntitlement: Boolean diff --git a/schema/adminsearch.graphql b/schema/adminsearch.graphql index 20afb8f5..35d50182 100644 --- a/schema/adminsearch.graphql +++ b/schema/adminsearch.graphql @@ -189,6 +189,15 @@ extend type Query{ query: String! ): OhAuthTooTokenSearchResult """ + Search across OrgSubscription objects + """ + adminOrgSubscriptionSearch( + """ + Search query + """ + query: String! + ): OrgSubscriptionSearchResult + """ Search across Organization objects """ adminOrganizationSearch( diff --git a/schema/ent.graphql b/schema/ent.graphql index 6b5470c5..774564e6 100644 --- a/schema/ent.graphql +++ b/schema/ent.graphql @@ -4465,6 +4465,49 @@ input CreateOrgMembershipInput { eventIDs: [ID!] } """ +CreateOrgSubscriptionInput is used for create OrgSubscription object. +Input was generated by ent. +""" +input CreateOrgSubscriptionInput { + """ + tags associated with the object + """ + tags: [String!] + """ + the stripe subscription id + """ + stripeSubscriptionID: String + """ + the common name of the product tier the subscription is associated with, e.g. starter tier + """ + productTier: String + """ + the product id that represents the tier in stripe + """ + stripeProductTierID: String + """ + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + """ + stripeSubscriptionStatus: String + """ + indicates if the subscription is active + """ + active: Boolean + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + """ + the features associated with the subscription + """ + features: [String!] + ownerID: ID +} +""" CreateOrganizationInput is used for create Organization object. Input was generated by ent. """ @@ -4513,6 +4556,7 @@ input CreateOrganizationInput { settingID: ID documentdatumIDs: [ID!] entitlementIDs: [ID!] + orgsubscriptionIDs: [ID!] organizationEntitlementIDs: [ID!] personalAccessTokenIDs: [ID!] apiTokenIDs: [ID!] @@ -17347,7 +17391,7 @@ input OrgMembershipWhereInput { roleIn: [OrgMembershipRole!] roleNotIn: [OrgMembershipRole!] } -type Organization implements Node { +type OrgSubscription implements Node { id: ID! createdAt: Time updatedAt: Time @@ -17360,140 +17404,51 @@ type Organization implements Node { deletedAt: Time deletedBy: String """ - the name of the organization - """ - name: String! - """ - The organization's displayed 'friendly' name - """ - displayName: String! - """ - An optional description of the organization - """ - description: String - """ - orgs directly associated with a user - """ - personalOrg: Boolean - """ - URL of the user's remote avatar - """ - avatarRemoteURL: String - """ - Whether the organization has a dedicated database - """ - dedicatedDb: Boolean! - """ - groups that are allowed to create controls + the organization id that owns the object """ - controlCreators: [Group!] + ownerID: ID """ - groups that are allowed to create control_objectives + the stripe subscription id """ - controlObjectiveCreators: [Group!] + stripeSubscriptionID: String """ - groups that are allowed to create groups + the common name of the product tier the subscription is associated with, e.g. starter tier """ - groupCreators: [Group!] + productTier: String """ - groups that are allowed to create internal_policys + the product id that represents the tier in stripe """ - internalPolicyCreators: [Group!] + stripeProductTierID: String """ - groups that are allowed to create narratives + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status """ - narrativeCreators: [Group!] + stripeSubscriptionStatus: String """ - groups that are allowed to create procedures + indicates if the subscription is active """ - procedureCreators: [Group!] + active: Boolean! """ - groups that are allowed to create programs + the customer ID the subscription is associated to """ - programCreators: [Group!] + stripeCustomerID: String """ - groups that are allowed to create risks + the time the subscription is set to expire; only populated if subscription is cancelled """ - riskCreators: [Group!] + expiresAt: Time """ - groups that are allowed to create templates + the features associated with the subscription """ - templateCreators: [Group!] - parent: Organization - children( - """ - Returns the elements in the list that come after the specified cursor. - """ - after: Cursor - - """ - Returns the first _n_ elements from the list. - """ - first: Int - - """ - Returns the elements in the list that come before the specified cursor. - """ - before: Cursor - - """ - Returns the last _n_ elements from the list. - """ - last: Int - - """ - Ordering options for Organizations returned from the connection. - """ - orderBy: OrganizationOrder - - """ - Filtering options for Organizations returned from the connection. - """ - where: OrganizationWhereInput - ): OrganizationConnection! - groups: [Group!] - templates: [Template!] - integrations: [Integration!] - setting: OrganizationSetting - documentdata: [DocumentData!] - entitlements: [Entitlement!] - organizationEntitlement: [Entitlement!] - personalAccessTokens: [PersonalAccessToken!] - apiTokens: [APIToken!] - oauthprovider: [OauthProvider!] - users: [User!] - invites: [Invite!] - subscribers: [Subscriber!] - webhooks: [Webhook!] - events: [Event!] - secrets: [Hush!] - features: [Feature!] - files: [File!] - entitlementplans: [EntitlementPlan!] - entitlementplanfeatures: [EntitlementPlanFeature!] - entities: [Entity!] - entitytypes: [EntityType!] - contacts: [Contact!] - notes: [Note!] - tasks: [Task!] - programs: [Program!] - procedures: [Procedure!] - internalpolicies: [InternalPolicy!] - risks: [Risk!] - controlobjectives: [ControlObjective!] - narratives: [Narrative!] - controls: [Control!] - subcontrols: [Subcontrol!] - members: [OrgMembership!] + features: [String!] + owner: Organization } """ A connection to a list of items. """ -type OrganizationConnection { +type OrgSubscriptionConnection { """ A list of edges. """ - edges: [OrganizationEdge] + edges: [OrgSubscriptionEdge] """ Information to aid in pagination. """ @@ -17506,21 +17461,21 @@ type OrganizationConnection { """ An edge in a connection. """ -type OrganizationEdge { +type OrgSubscriptionEdge { """ The item at the end of the edge. """ - node: Organization + node: OrgSubscription """ A cursor for use in pagination. """ cursor: Cursor! } -type OrganizationHistory implements Node { +type OrgSubscriptionHistory implements Node { id: ID! historyTime: Time! ref: String - operation: OrganizationHistoryOpType! + operation: OrgSubscriptionHistoryOpType! createdAt: Time updatedAt: Time createdBy: String @@ -17532,38 +17487,50 @@ type OrganizationHistory implements Node { deletedAt: Time deletedBy: String """ - the name of the organization + the organization id that owns the object """ - name: String! + ownerID: String """ - The organization's displayed 'friendly' name + the stripe subscription id """ - displayName: String! + stripeSubscriptionID: String """ - An optional description of the organization + the common name of the product tier the subscription is associated with, e.g. starter tier """ - description: String + productTier: String """ - orgs directly associated with a user + the product id that represents the tier in stripe """ - personalOrg: Boolean + stripeProductTierID: String """ - URL of the user's remote avatar + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status """ - avatarRemoteURL: String + stripeSubscriptionStatus: String """ - Whether the organization has a dedicated database + indicates if the subscription is active """ - dedicatedDb: Boolean! + active: Boolean! + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + """ + the features associated with the subscription + """ + features: [String!] } """ A connection to a list of items. """ -type OrganizationHistoryConnection { +type OrgSubscriptionHistoryConnection { """ A list of edges. """ - edges: [OrganizationHistoryEdge] + edges: [OrgSubscriptionHistoryEdge] """ Information to aid in pagination. """ @@ -17576,52 +17543,32 @@ type OrganizationHistoryConnection { """ An edge in a connection. """ -type OrganizationHistoryEdge { +type OrgSubscriptionHistoryEdge { """ The item at the end of the edge. """ - node: OrganizationHistory + node: OrgSubscriptionHistory """ A cursor for use in pagination. """ cursor: Cursor! } """ -OrganizationHistoryOpType is enum for the field operation +OrgSubscriptionHistoryOpType is enum for the field operation """ -enum OrganizationHistoryOpType @goModel(model: "github.com/theopenlane/entx/history.OpType") { +enum OrgSubscriptionHistoryOpType @goModel(model: "github.com/theopenlane/entx/history.OpType") { INSERT UPDATE DELETE } """ -Ordering options for OrganizationHistory connections -""" -input OrganizationHistoryOrder { - """ - The ordering direction. - """ - direction: OrderDirection! = ASC - """ - The field by which to order OrganizationHistories. - """ - field: OrganizationHistoryOrderField! -} -""" -Properties by which OrganizationHistory connections can be ordered. -""" -enum OrganizationHistoryOrderField { - name - display_name -} -""" -OrganizationHistoryWhereInput is used for filtering OrganizationHistory objects. +OrgSubscriptionHistoryWhereInput is used for filtering OrgSubscriptionHistory objects. Input was generated by ent. """ -input OrganizationHistoryWhereInput { - not: OrganizationHistoryWhereInput - and: [OrganizationHistoryWhereInput!] - or: [OrganizationHistoryWhereInput!] +input OrgSubscriptionHistoryWhereInput { + not: OrgSubscriptionHistoryWhereInput + and: [OrgSubscriptionHistoryWhereInput!] + or: [OrgSubscriptionHistoryWhereInput!] """ id field predicates """ @@ -17667,10 +17614,10 @@ input OrganizationHistoryWhereInput { """ operation field predicates """ - operation: OrganizationHistoryOpType - operationNEQ: OrganizationHistoryOpType - operationIn: [OrganizationHistoryOpType!] - operationNotIn: [OrganizationHistoryOpType!] + operation: OrgSubscriptionHistoryOpType + operationNEQ: OrgSubscriptionHistoryOpType + operationIn: [OrgSubscriptionHistoryOpType!] + operationNotIn: [OrgSubscriptionHistoryOpType!] """ created_at field predicates """ @@ -17765,44 +17712,835 @@ input OrganizationHistoryWhereInput { deletedByEqualFold: String deletedByContainsFold: String """ - display_name field predicates + owner_id field predicates """ - displayName: String - displayNameNEQ: String - displayNameIn: [String!] - displayNameNotIn: [String!] - displayNameGT: String - displayNameGTE: String - displayNameLT: String - displayNameLTE: String - displayNameContains: String - displayNameHasPrefix: String - displayNameHasSuffix: String - displayNameEqualFold: String - displayNameContainsFold: String + ownerID: String + ownerIDNEQ: String + ownerIDIn: [String!] + ownerIDNotIn: [String!] + ownerIDGT: String + ownerIDGTE: String + ownerIDLT: String + ownerIDLTE: String + ownerIDContains: String + ownerIDHasPrefix: String + ownerIDHasSuffix: String + ownerIDIsNil: Boolean + ownerIDNotNil: Boolean + ownerIDEqualFold: String + ownerIDContainsFold: String """ - parent_organization_id field predicates + stripe_subscription_id field predicates + """ + stripeSubscriptionID: String + stripeSubscriptionIDNEQ: String + stripeSubscriptionIDIn: [String!] + stripeSubscriptionIDNotIn: [String!] + stripeSubscriptionIDGT: String + stripeSubscriptionIDGTE: String + stripeSubscriptionIDLT: String + stripeSubscriptionIDLTE: String + stripeSubscriptionIDContains: String + stripeSubscriptionIDHasPrefix: String + stripeSubscriptionIDHasSuffix: String + stripeSubscriptionIDIsNil: Boolean + stripeSubscriptionIDNotNil: Boolean + stripeSubscriptionIDEqualFold: String + stripeSubscriptionIDContainsFold: String + """ + product_tier field predicates + """ + productTier: String + productTierNEQ: String + productTierIn: [String!] + productTierNotIn: [String!] + productTierGT: String + productTierGTE: String + productTierLT: String + productTierLTE: String + productTierContains: String + productTierHasPrefix: String + productTierHasSuffix: String + productTierIsNil: Boolean + productTierNotNil: Boolean + productTierEqualFold: String + productTierContainsFold: String + """ + stripe_product_tier_id field predicates + """ + stripeProductTierID: String + stripeProductTierIDNEQ: String + stripeProductTierIDIn: [String!] + stripeProductTierIDNotIn: [String!] + stripeProductTierIDGT: String + stripeProductTierIDGTE: String + stripeProductTierIDLT: String + stripeProductTierIDLTE: String + stripeProductTierIDContains: String + stripeProductTierIDHasPrefix: String + stripeProductTierIDHasSuffix: String + stripeProductTierIDIsNil: Boolean + stripeProductTierIDNotNil: Boolean + stripeProductTierIDEqualFold: String + stripeProductTierIDContainsFold: String + """ + stripe_subscription_status field predicates + """ + stripeSubscriptionStatus: String + stripeSubscriptionStatusNEQ: String + stripeSubscriptionStatusIn: [String!] + stripeSubscriptionStatusNotIn: [String!] + stripeSubscriptionStatusGT: String + stripeSubscriptionStatusGTE: String + stripeSubscriptionStatusLT: String + stripeSubscriptionStatusLTE: String + stripeSubscriptionStatusContains: String + stripeSubscriptionStatusHasPrefix: String + stripeSubscriptionStatusHasSuffix: String + stripeSubscriptionStatusIsNil: Boolean + stripeSubscriptionStatusNotNil: Boolean + stripeSubscriptionStatusEqualFold: String + stripeSubscriptionStatusContainsFold: String """ - parentOrganizationID: ID - parentOrganizationIDNEQ: ID - parentOrganizationIDIn: [ID!] - parentOrganizationIDNotIn: [ID!] - parentOrganizationIDGT: ID - parentOrganizationIDGTE: ID - parentOrganizationIDLT: ID - parentOrganizationIDLTE: ID - parentOrganizationIDContains: ID - parentOrganizationIDHasPrefix: ID - parentOrganizationIDHasSuffix: ID - parentOrganizationIDIsNil: Boolean - parentOrganizationIDNotNil: Boolean - parentOrganizationIDEqualFold: ID - parentOrganizationIDContainsFold: ID + active field predicates """ - personal_org field predicates + active: Boolean + activeNEQ: Boolean """ - personalOrg: Boolean - personalOrgNEQ: Boolean + stripe_customer_id field predicates + """ + stripeCustomerID: String + stripeCustomerIDNEQ: String + stripeCustomerIDIn: [String!] + stripeCustomerIDNotIn: [String!] + stripeCustomerIDGT: String + stripeCustomerIDGTE: String + stripeCustomerIDLT: String + stripeCustomerIDLTE: String + stripeCustomerIDContains: String + stripeCustomerIDHasPrefix: String + stripeCustomerIDHasSuffix: String + stripeCustomerIDIsNil: Boolean + stripeCustomerIDNotNil: Boolean + stripeCustomerIDEqualFold: String + stripeCustomerIDContainsFold: String + """ + expires_at field predicates + """ + expiresAt: Time + expiresAtNEQ: Time + expiresAtIn: [Time!] + expiresAtNotIn: [Time!] + expiresAtGT: Time + expiresAtGTE: Time + expiresAtLT: Time + expiresAtLTE: Time + expiresAtIsNil: Boolean + expiresAtNotNil: Boolean +} +""" +OrgSubscriptionWhereInput is used for filtering OrgSubscription objects. +Input was generated by ent. +""" +input OrgSubscriptionWhereInput { + not: OrgSubscriptionWhereInput + and: [OrgSubscriptionWhereInput!] + or: [OrgSubscriptionWhereInput!] + """ + id field predicates + """ + id: ID + idNEQ: ID + idIn: [ID!] + idNotIn: [ID!] + idGT: ID + idGTE: ID + idLT: ID + idLTE: ID + idEqualFold: ID + idContainsFold: ID + """ + created_at field predicates + """ + createdAt: Time + createdAtNEQ: Time + createdAtIn: [Time!] + createdAtNotIn: [Time!] + createdAtGT: Time + createdAtGTE: Time + createdAtLT: Time + createdAtLTE: Time + createdAtIsNil: Boolean + createdAtNotNil: Boolean + """ + updated_at field predicates + """ + updatedAt: Time + updatedAtNEQ: Time + updatedAtIn: [Time!] + updatedAtNotIn: [Time!] + updatedAtGT: Time + updatedAtGTE: Time + updatedAtLT: Time + updatedAtLTE: Time + updatedAtIsNil: Boolean + updatedAtNotNil: Boolean + """ + created_by field predicates + """ + createdBy: String + createdByNEQ: String + createdByIn: [String!] + createdByNotIn: [String!] + createdByGT: String + createdByGTE: String + createdByLT: String + createdByLTE: String + createdByContains: String + createdByHasPrefix: String + createdByHasSuffix: String + createdByIsNil: Boolean + createdByNotNil: Boolean + createdByEqualFold: String + createdByContainsFold: String + """ + updated_by field predicates + """ + updatedBy: String + updatedByNEQ: String + updatedByIn: [String!] + updatedByNotIn: [String!] + updatedByGT: String + updatedByGTE: String + updatedByLT: String + updatedByLTE: String + updatedByContains: String + updatedByHasPrefix: String + updatedByHasSuffix: String + updatedByIsNil: Boolean + updatedByNotNil: Boolean + updatedByEqualFold: String + updatedByContainsFold: String + """ + deleted_at field predicates + """ + deletedAt: Time + deletedAtNEQ: Time + deletedAtIn: [Time!] + deletedAtNotIn: [Time!] + deletedAtGT: Time + deletedAtGTE: Time + deletedAtLT: Time + deletedAtLTE: Time + deletedAtIsNil: Boolean + deletedAtNotNil: Boolean + """ + deleted_by field predicates + """ + deletedBy: String + deletedByNEQ: String + deletedByIn: [String!] + deletedByNotIn: [String!] + deletedByGT: String + deletedByGTE: String + deletedByLT: String + deletedByLTE: String + deletedByContains: String + deletedByHasPrefix: String + deletedByHasSuffix: String + deletedByIsNil: Boolean + deletedByNotNil: Boolean + deletedByEqualFold: String + deletedByContainsFold: String + """ + owner_id field predicates + """ + ownerID: ID + ownerIDNEQ: ID + ownerIDIn: [ID!] + ownerIDNotIn: [ID!] + ownerIDGT: ID + ownerIDGTE: ID + ownerIDLT: ID + ownerIDLTE: ID + ownerIDContains: ID + ownerIDHasPrefix: ID + ownerIDHasSuffix: ID + ownerIDIsNil: Boolean + ownerIDNotNil: Boolean + ownerIDEqualFold: ID + ownerIDContainsFold: ID + """ + stripe_subscription_id field predicates + """ + stripeSubscriptionID: String + stripeSubscriptionIDNEQ: String + stripeSubscriptionIDIn: [String!] + stripeSubscriptionIDNotIn: [String!] + stripeSubscriptionIDGT: String + stripeSubscriptionIDGTE: String + stripeSubscriptionIDLT: String + stripeSubscriptionIDLTE: String + stripeSubscriptionIDContains: String + stripeSubscriptionIDHasPrefix: String + stripeSubscriptionIDHasSuffix: String + stripeSubscriptionIDIsNil: Boolean + stripeSubscriptionIDNotNil: Boolean + stripeSubscriptionIDEqualFold: String + stripeSubscriptionIDContainsFold: String + """ + product_tier field predicates + """ + productTier: String + productTierNEQ: String + productTierIn: [String!] + productTierNotIn: [String!] + productTierGT: String + productTierGTE: String + productTierLT: String + productTierLTE: String + productTierContains: String + productTierHasPrefix: String + productTierHasSuffix: String + productTierIsNil: Boolean + productTierNotNil: Boolean + productTierEqualFold: String + productTierContainsFold: String + """ + stripe_product_tier_id field predicates + """ + stripeProductTierID: String + stripeProductTierIDNEQ: String + stripeProductTierIDIn: [String!] + stripeProductTierIDNotIn: [String!] + stripeProductTierIDGT: String + stripeProductTierIDGTE: String + stripeProductTierIDLT: String + stripeProductTierIDLTE: String + stripeProductTierIDContains: String + stripeProductTierIDHasPrefix: String + stripeProductTierIDHasSuffix: String + stripeProductTierIDIsNil: Boolean + stripeProductTierIDNotNil: Boolean + stripeProductTierIDEqualFold: String + stripeProductTierIDContainsFold: String + """ + stripe_subscription_status field predicates + """ + stripeSubscriptionStatus: String + stripeSubscriptionStatusNEQ: String + stripeSubscriptionStatusIn: [String!] + stripeSubscriptionStatusNotIn: [String!] + stripeSubscriptionStatusGT: String + stripeSubscriptionStatusGTE: String + stripeSubscriptionStatusLT: String + stripeSubscriptionStatusLTE: String + stripeSubscriptionStatusContains: String + stripeSubscriptionStatusHasPrefix: String + stripeSubscriptionStatusHasSuffix: String + stripeSubscriptionStatusIsNil: Boolean + stripeSubscriptionStatusNotNil: Boolean + stripeSubscriptionStatusEqualFold: String + stripeSubscriptionStatusContainsFold: String + """ + active field predicates + """ + active: Boolean + activeNEQ: Boolean + """ + stripe_customer_id field predicates + """ + stripeCustomerID: String + stripeCustomerIDNEQ: String + stripeCustomerIDIn: [String!] + stripeCustomerIDNotIn: [String!] + stripeCustomerIDGT: String + stripeCustomerIDGTE: String + stripeCustomerIDLT: String + stripeCustomerIDLTE: String + stripeCustomerIDContains: String + stripeCustomerIDHasPrefix: String + stripeCustomerIDHasSuffix: String + stripeCustomerIDIsNil: Boolean + stripeCustomerIDNotNil: Boolean + stripeCustomerIDEqualFold: String + stripeCustomerIDContainsFold: String + """ + expires_at field predicates + """ + expiresAt: Time + expiresAtNEQ: Time + expiresAtIn: [Time!] + expiresAtNotIn: [Time!] + expiresAtGT: Time + expiresAtGTE: Time + expiresAtLT: Time + expiresAtLTE: Time + expiresAtIsNil: Boolean + expiresAtNotNil: Boolean + """ + owner edge predicates + """ + hasOwner: Boolean + hasOwnerWith: [OrganizationWhereInput!] +} +type Organization implements Node { + id: ID! + createdAt: Time + updatedAt: Time + createdBy: String + updatedBy: String + """ + tags associated with the object + """ + tags: [String!] + deletedAt: Time + deletedBy: String + """ + the name of the organization + """ + name: String! + """ + The organization's displayed 'friendly' name + """ + displayName: String! + """ + An optional description of the organization + """ + description: String + """ + orgs directly associated with a user + """ + personalOrg: Boolean + """ + URL of the user's remote avatar + """ + avatarRemoteURL: String + """ + Whether the organization has a dedicated database + """ + dedicatedDb: Boolean! + """ + groups that are allowed to create controls + """ + controlCreators: [Group!] + """ + groups that are allowed to create control_objectives + """ + controlObjectiveCreators: [Group!] + """ + groups that are allowed to create groups + """ + groupCreators: [Group!] + """ + groups that are allowed to create internal_policys + """ + internalPolicyCreators: [Group!] + """ + groups that are allowed to create narratives + """ + narrativeCreators: [Group!] + """ + groups that are allowed to create procedures + """ + procedureCreators: [Group!] + """ + groups that are allowed to create programs + """ + programCreators: [Group!] + """ + groups that are allowed to create risks + """ + riskCreators: [Group!] + """ + groups that are allowed to create templates + """ + templateCreators: [Group!] + parent: Organization + children( + """ + Returns the elements in the list that come after the specified cursor. + """ + after: Cursor + + """ + Returns the first _n_ elements from the list. + """ + first: Int + + """ + Returns the elements in the list that come before the specified cursor. + """ + before: Cursor + + """ + Returns the last _n_ elements from the list. + """ + last: Int + + """ + Ordering options for Organizations returned from the connection. + """ + orderBy: OrganizationOrder + + """ + Filtering options for Organizations returned from the connection. + """ + where: OrganizationWhereInput + ): OrganizationConnection! + groups: [Group!] + templates: [Template!] + integrations: [Integration!] + setting: OrganizationSetting + documentdata: [DocumentData!] + entitlements: [Entitlement!] + orgsubscriptions: [OrgSubscription!] + organizationEntitlement: [Entitlement!] + personalAccessTokens: [PersonalAccessToken!] + apiTokens: [APIToken!] + oauthprovider: [OauthProvider!] + users: [User!] + invites: [Invite!] + subscribers: [Subscriber!] + webhooks: [Webhook!] + events: [Event!] + secrets: [Hush!] + features: [Feature!] + files: [File!] + entitlementplans: [EntitlementPlan!] + entitlementplanfeatures: [EntitlementPlanFeature!] + entities: [Entity!] + entitytypes: [EntityType!] + contacts: [Contact!] + notes: [Note!] + tasks: [Task!] + programs: [Program!] + procedures: [Procedure!] + internalpolicies: [InternalPolicy!] + risks: [Risk!] + controlobjectives: [ControlObjective!] + narratives: [Narrative!] + controls: [Control!] + subcontrols: [Subcontrol!] + members: [OrgMembership!] +} +""" +A connection to a list of items. +""" +type OrganizationConnection { + """ + A list of edges. + """ + edges: [OrganizationEdge] + """ + Information to aid in pagination. + """ + pageInfo: PageInfo! + """ + Identifies the total count of items in the connection. + """ + totalCount: Int! +} +""" +An edge in a connection. +""" +type OrganizationEdge { + """ + The item at the end of the edge. + """ + node: Organization + """ + A cursor for use in pagination. + """ + cursor: Cursor! +} +type OrganizationHistory implements Node { + id: ID! + historyTime: Time! + ref: String + operation: OrganizationHistoryOpType! + createdAt: Time + updatedAt: Time + createdBy: String + updatedBy: String + """ + tags associated with the object + """ + tags: [String!] + deletedAt: Time + deletedBy: String + """ + the name of the organization + """ + name: String! + """ + The organization's displayed 'friendly' name + """ + displayName: String! + """ + An optional description of the organization + """ + description: String + """ + orgs directly associated with a user + """ + personalOrg: Boolean + """ + URL of the user's remote avatar + """ + avatarRemoteURL: String + """ + Whether the organization has a dedicated database + """ + dedicatedDb: Boolean! +} +""" +A connection to a list of items. +""" +type OrganizationHistoryConnection { + """ + A list of edges. + """ + edges: [OrganizationHistoryEdge] + """ + Information to aid in pagination. + """ + pageInfo: PageInfo! + """ + Identifies the total count of items in the connection. + """ + totalCount: Int! +} +""" +An edge in a connection. +""" +type OrganizationHistoryEdge { + """ + The item at the end of the edge. + """ + node: OrganizationHistory + """ + A cursor for use in pagination. + """ + cursor: Cursor! +} +""" +OrganizationHistoryOpType is enum for the field operation +""" +enum OrganizationHistoryOpType @goModel(model: "github.com/theopenlane/entx/history.OpType") { + INSERT + UPDATE + DELETE +} +""" +Ordering options for OrganizationHistory connections +""" +input OrganizationHistoryOrder { + """ + The ordering direction. + """ + direction: OrderDirection! = ASC + """ + The field by which to order OrganizationHistories. + """ + field: OrganizationHistoryOrderField! +} +""" +Properties by which OrganizationHistory connections can be ordered. +""" +enum OrganizationHistoryOrderField { + name + display_name +} +""" +OrganizationHistoryWhereInput is used for filtering OrganizationHistory objects. +Input was generated by ent. +""" +input OrganizationHistoryWhereInput { + not: OrganizationHistoryWhereInput + and: [OrganizationHistoryWhereInput!] + or: [OrganizationHistoryWhereInput!] + """ + id field predicates + """ + id: ID + idNEQ: ID + idIn: [ID!] + idNotIn: [ID!] + idGT: ID + idGTE: ID + idLT: ID + idLTE: ID + idEqualFold: ID + idContainsFold: ID + """ + history_time field predicates + """ + historyTime: Time + historyTimeNEQ: Time + historyTimeIn: [Time!] + historyTimeNotIn: [Time!] + historyTimeGT: Time + historyTimeGTE: Time + historyTimeLT: Time + historyTimeLTE: Time + """ + ref field predicates + """ + ref: String + refNEQ: String + refIn: [String!] + refNotIn: [String!] + refGT: String + refGTE: String + refLT: String + refLTE: String + refContains: String + refHasPrefix: String + refHasSuffix: String + refIsNil: Boolean + refNotNil: Boolean + refEqualFold: String + refContainsFold: String + """ + operation field predicates + """ + operation: OrganizationHistoryOpType + operationNEQ: OrganizationHistoryOpType + operationIn: [OrganizationHistoryOpType!] + operationNotIn: [OrganizationHistoryOpType!] + """ + created_at field predicates + """ + createdAt: Time + createdAtNEQ: Time + createdAtIn: [Time!] + createdAtNotIn: [Time!] + createdAtGT: Time + createdAtGTE: Time + createdAtLT: Time + createdAtLTE: Time + createdAtIsNil: Boolean + createdAtNotNil: Boolean + """ + updated_at field predicates + """ + updatedAt: Time + updatedAtNEQ: Time + updatedAtIn: [Time!] + updatedAtNotIn: [Time!] + updatedAtGT: Time + updatedAtGTE: Time + updatedAtLT: Time + updatedAtLTE: Time + updatedAtIsNil: Boolean + updatedAtNotNil: Boolean + """ + created_by field predicates + """ + createdBy: String + createdByNEQ: String + createdByIn: [String!] + createdByNotIn: [String!] + createdByGT: String + createdByGTE: String + createdByLT: String + createdByLTE: String + createdByContains: String + createdByHasPrefix: String + createdByHasSuffix: String + createdByIsNil: Boolean + createdByNotNil: Boolean + createdByEqualFold: String + createdByContainsFold: String + """ + updated_by field predicates + """ + updatedBy: String + updatedByNEQ: String + updatedByIn: [String!] + updatedByNotIn: [String!] + updatedByGT: String + updatedByGTE: String + updatedByLT: String + updatedByLTE: String + updatedByContains: String + updatedByHasPrefix: String + updatedByHasSuffix: String + updatedByIsNil: Boolean + updatedByNotNil: Boolean + updatedByEqualFold: String + updatedByContainsFold: String + """ + deleted_at field predicates + """ + deletedAt: Time + deletedAtNEQ: Time + deletedAtIn: [Time!] + deletedAtNotIn: [Time!] + deletedAtGT: Time + deletedAtGTE: Time + deletedAtLT: Time + deletedAtLTE: Time + deletedAtIsNil: Boolean + deletedAtNotNil: Boolean + """ + deleted_by field predicates + """ + deletedBy: String + deletedByNEQ: String + deletedByIn: [String!] + deletedByNotIn: [String!] + deletedByGT: String + deletedByGTE: String + deletedByLT: String + deletedByLTE: String + deletedByContains: String + deletedByHasPrefix: String + deletedByHasSuffix: String + deletedByIsNil: Boolean + deletedByNotNil: Boolean + deletedByEqualFold: String + deletedByContainsFold: String + """ + display_name field predicates + """ + displayName: String + displayNameNEQ: String + displayNameIn: [String!] + displayNameNotIn: [String!] + displayNameGT: String + displayNameGTE: String + displayNameLT: String + displayNameLTE: String + displayNameContains: String + displayNameHasPrefix: String + displayNameHasSuffix: String + displayNameEqualFold: String + displayNameContainsFold: String + """ + parent_organization_id field predicates + """ + parentOrganizationID: ID + parentOrganizationIDNEQ: ID + parentOrganizationIDIn: [ID!] + parentOrganizationIDNotIn: [ID!] + parentOrganizationIDGT: ID + parentOrganizationIDGTE: ID + parentOrganizationIDLT: ID + parentOrganizationIDLTE: ID + parentOrganizationIDContains: ID + parentOrganizationIDHasPrefix: ID + parentOrganizationIDHasSuffix: ID + parentOrganizationIDIsNil: Boolean + parentOrganizationIDNotNil: Boolean + parentOrganizationIDEqualFold: ID + parentOrganizationIDContainsFold: ID + """ + personal_org field predicates + """ + personalOrg: Boolean + personalOrgNEQ: Boolean personalOrgIsNil: Boolean personalOrgNotNil: Boolean """ @@ -18836,6 +19574,11 @@ input OrganizationWhereInput { hasEntitlements: Boolean hasEntitlementsWith: [EntitlementWhereInput!] """ + orgsubscriptions edge predicates + """ + hasOrgsubscriptions: Boolean + hasOrgsubscriptionsWith: [OrgSubscriptionWhereInput!] + """ organization_entitlement edge predicates """ hasOrganizationEntitlement: Boolean @@ -22598,6 +23341,58 @@ type Query { """ where: OrgMembershipHistoryWhereInput ): OrgMembershipHistoryConnection! + orgSubscriptions( + """ + Returns the elements in the list that come after the specified cursor. + """ + after: Cursor + + """ + Returns the first _n_ elements from the list. + """ + first: Int + + """ + Returns the elements in the list that come before the specified cursor. + """ + before: Cursor + + """ + Returns the last _n_ elements from the list. + """ + last: Int + + """ + Filtering options for OrgSubscriptions returned from the connection. + """ + where: OrgSubscriptionWhereInput + ): OrgSubscriptionConnection! + orgSubscriptionHistories( + """ + Returns the elements in the list that come after the specified cursor. + """ + after: Cursor + + """ + Returns the first _n_ elements from the list. + """ + first: Int + + """ + Returns the elements in the list that come before the specified cursor. + """ + before: Cursor + + """ + Returns the last _n_ elements from the list. + """ + last: Int + + """ + Filtering options for OrgSubscriptionHistories returned from the connection. + """ + where: OrgSubscriptionHistoryWhereInput + ): OrgSubscriptionHistoryConnection! organizations( """ Returns the elements in the list that come after the specified cursor. @@ -29145,6 +29940,60 @@ input UpdateOrgMembershipInput { clearEvents: Boolean } """ +UpdateOrgSubscriptionInput is used for update OrgSubscription object. +Input was generated by ent. +""" +input UpdateOrgSubscriptionInput { + """ + tags associated with the object + """ + tags: [String!] + appendTags: [String!] + clearTags: Boolean + """ + the stripe subscription id + """ + stripeSubscriptionID: String + clearStripeSubscriptionID: Boolean + """ + the common name of the product tier the subscription is associated with, e.g. starter tier + """ + productTier: String + clearProductTier: Boolean + """ + the product id that represents the tier in stripe + """ + stripeProductTierID: String + clearStripeProductTierID: Boolean + """ + the status of the subscription in stripe -- see https://docs.stripe.com/api/subscriptions/object#subscription_object-status + """ + stripeSubscriptionStatus: String + clearStripeSubscriptionStatus: Boolean + """ + indicates if the subscription is active + """ + active: Boolean + """ + the customer ID the subscription is associated to + """ + stripeCustomerID: String + clearStripeCustomerID: Boolean + """ + the time the subscription is set to expire; only populated if subscription is cancelled + """ + expiresAt: Time + clearExpiresAt: Boolean + """ + the features associated with the subscription + """ + features: [String!] + appendFeatures: [String!] + clearFeatures: Boolean + ownerID: ID + clearOwner: Boolean +} +""" UpdateOrganizationInput is used for update Organization object. Input was generated by ent. """ @@ -29217,6 +30066,9 @@ input UpdateOrganizationInput { addEntitlementIDs: [ID!] removeEntitlementIDs: [ID!] clearEntitlements: Boolean + addOrgsubscriptionIDs: [ID!] + removeOrgsubscriptionIDs: [ID!] + clearOrgsubscriptions: Boolean addOrganizationEntitlementIDs: [ID!] removeOrganizationEntitlementIDs: [ID!] clearOrganizationEntitlement: Boolean diff --git a/schema/orgsubscription.graphql b/schema/orgsubscription.graphql new file mode 100644 index 00000000..f1d1fd73 --- /dev/null +++ b/schema/orgsubscription.graphql @@ -0,0 +1,103 @@ +extend type Query { + """ + Look up orgSubscription by ID + """ + orgSubscription( + """ + ID of the orgSubscription + """ + id: ID! + ): OrgSubscription! +} + +extend type Mutation{ + """ + Create a new orgSubscription + """ + createOrgSubscription( + """ + values of the orgSubscription + """ + input: CreateOrgSubscriptionInput! + ): OrgSubscriptionCreatePayload! + """ + Create multiple new orgSubscriptions + """ + createBulkOrgSubscription( + """ + values of the orgSubscription + """ + input: [CreateOrgSubscriptionInput!] + ): OrgSubscriptionBulkCreatePayload! + """ + Create multiple new orgSubscriptions via file upload + """ + createBulkCSVOrgSubscription( + """ + csv file containing values of the orgSubscription + """ + input: Upload! + ): OrgSubscriptionBulkCreatePayload! + """ + Update an existing orgSubscription + """ + updateOrgSubscription( + """ + ID of the orgSubscription + """ + id: ID! + """ + New values for the orgSubscription + """ + input: UpdateOrgSubscriptionInput! + ): OrgSubscriptionUpdatePayload! + """ + Delete an existing orgSubscription + """ + deleteOrgSubscription( + """ + ID of the orgSubscription + """ + id: ID! + ): OrgSubscriptionDeletePayload! +} + +""" +Return response for createOrgSubscription mutation +""" +type OrgSubscriptionCreatePayload { + """ + Created orgSubscription + """ + orgSubscription: OrgSubscription! +} + +""" +Return response for updateOrgSubscription mutation +""" +type OrgSubscriptionUpdatePayload { + """ + Updated orgSubscription + """ + orgSubscription: OrgSubscription! +} + +""" +Return response for deleteOrgSubscription mutation +""" +type OrgSubscriptionDeletePayload { + """ + Deleted orgSubscription ID + """ + deletedID: ID! +} + +""" +Return response for createBulkOrgSubscription mutation +""" +type OrgSubscriptionBulkCreatePayload { + """ + Created orgSubscriptions + """ + orgSubscriptions: [OrgSubscription!] +} \ No newline at end of file diff --git a/schema/search.graphql b/schema/search.graphql index fc776872..2e6e20fe 100644 --- a/schema/search.graphql +++ b/schema/search.graphql @@ -189,6 +189,15 @@ extend type Query{ query: String! ): OhAuthTooTokenSearchResult """ + Search across OrgSubscription objects + """ + orgSubscriptionSearch( + """ + Search query + """ + query: String! + ): OrgSubscriptionSearchResult + """ Search across Organization objects """ organizationSearch( @@ -346,6 +355,7 @@ union SearchResult = | NarrativeSearchResult | OauthProviderSearchResult | OhAuthTooTokenSearchResult + | OrgSubscriptionSearchResult | OrganizationSearchResult | OrganizationSettingSearchResult | PersonalAccessTokenSearchResult @@ -473,6 +483,10 @@ type OhAuthTooTokenSearchResult { ohAuthTooTokens: [ OhAuthTooToken!] } +type OrgSubscriptionSearchResult { + orgSubscriptions: [ OrgSubscription!] +} + type OrganizationSearchResult { organizations: [ Organization!] }