@stigg/node-server-sdk 0.18.1

package/dist/api/generated/types.d.ts

@@ -0,0 +1,2413 @@
+export declare type Maybe<T> = T | null;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    /** Cursor for paging through collections */
+    ConnectionCursor: any;
+    /** A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format. */
+    DateTime: any;
+};
+/** DenyReason of get access policy */
+export declare enum AccessDeniedReason {
+    CustomerNotFound = "CustomerNotFound",
+    FeatureNotFound = "FeatureNotFound",
+    NoActiveSubscription = "NoActiveSubscription",
+    NoFeatureEntitlementInSubscription = "NoFeatureEntitlementInSubscription",
+    RequestedUsageExceedingLimit = "RequestedUsageExceedingLimit",
+    Unknown = "Unknown"
+}
+export declare type AddAddonsToCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type AddApiKeysToEnvironmentInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type AddCompatibleAddonsToPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type AddPricesToAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type AddPricesToCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type AddPricesToPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type AddSubscriptionsToCustomerInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type AddonCreateInput = {
+    billingId?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    displayName: Scalars['String'];
+    environmentId: Scalars['String'];
+    productId: Scalars['String'];
+    refId: Scalars['String'];
+    status?: Maybe<PackageStatus>;
+};
+export declare type AddonDeleteFilter = {
+    and?: Maybe<Array<AddonDeleteFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isLatest?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<AddonDeleteFilter>>;
+    productId?: Maybe<StringFieldComparison>;
+    refId?: Maybe<StringFieldComparison>;
+    status?: Maybe<PackageStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+    versionNumber?: Maybe<IntFieldComparison>;
+};
+export declare type AddonFilter = {
+    and?: Maybe<Array<AddonFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isLatest?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<AddonFilter>>;
+    productId?: Maybe<StringFieldComparison>;
+    refId?: Maybe<StringFieldComparison>;
+    status?: Maybe<PackageStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+    versionNumber?: Maybe<IntFieldComparison>;
+};
+export declare type AddonSort = {
+    direction: SortDirection;
+    field: AddonSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum AddonSortFields {
+    BillingId = "billingId",
+    CreatedAt = "createdAt",
+    Description = "description",
+    DisplayName = "displayName",
+    EnvironmentId = "environmentId",
+    Id = "id",
+    IsLatest = "isLatest",
+    ProductId = "productId",
+    RefId = "refId",
+    Status = "status",
+    UpdatedAt = "updatedAt",
+    VersionNumber = "versionNumber"
+}
+export declare type AddonUpdateInput = {
+    billingId?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    displayName: Scalars['String'];
+    id: Scalars['String'];
+    status?: Maybe<PackageStatus>;
+};
+export declare type ApiKeyFilter = {
+    and?: Maybe<Array<ApiKeyFilter>>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<ApiKeyFilter>>;
+};
+export declare type ApiKeySort = {
+    direction: SortDirection;
+    field: ApiKeySortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum ApiKeySortFields {
+    Id = "id"
+}
+export declare enum ApiKeyType {
+    Client = "CLIENT",
+    Server = "SERVER"
+}
+/** Billing model. */
+export declare enum BillingModel {
+    FlatFee = "FLAT_FEE",
+    PerUnit = "PER_UNIT",
+    UsageBased = "USAGE_BASED"
+}
+export declare type BillingModelFilterComparison = {
+    eq?: Maybe<BillingModel>;
+    gt?: Maybe<BillingModel>;
+    gte?: Maybe<BillingModel>;
+    iLike?: Maybe<BillingModel>;
+    in?: Maybe<Array<BillingModel>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<BillingModel>;
+    lt?: Maybe<BillingModel>;
+    lte?: Maybe<BillingModel>;
+    neq?: Maybe<BillingModel>;
+    notILike?: Maybe<BillingModel>;
+    notIn?: Maybe<Array<BillingModel>>;
+    notLike?: Maybe<BillingModel>;
+};
+/** Billing period. */
+export declare enum BillingPeriod {
+    Annually = "ANNUALLY",
+    Monthly = "MONTHLY"
+}
+export declare type BillingPeriodFilterComparison = {
+    eq?: Maybe<BillingPeriod>;
+    gt?: Maybe<BillingPeriod>;
+    gte?: Maybe<BillingPeriod>;
+    iLike?: Maybe<BillingPeriod>;
+    in?: Maybe<Array<BillingPeriod>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<BillingPeriod>;
+    lt?: Maybe<BillingPeriod>;
+    lte?: Maybe<BillingPeriod>;
+    neq?: Maybe<BillingPeriod>;
+    notILike?: Maybe<BillingPeriod>;
+    notIn?: Maybe<Array<BillingPeriod>>;
+    notLike?: Maybe<BillingPeriod>;
+};
+export declare type BooleanFieldComparison = {
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+};
+export declare enum ChangeType {
+    Added = "ADDED",
+    Deleted = "DELETED",
+    Modified = "MODIFIED"
+}
+export declare type CheckoutAddonInput = {
+    addonId: Scalars['String'];
+    quantity?: Maybe<Scalars['Int']>;
+};
+export declare type CreateEnvironment = {
+    description?: Maybe<Scalars['String']>;
+    displayName?: Maybe<Scalars['String']>;
+    id?: Maybe<Scalars['String']>;
+    slug?: Maybe<Scalars['String']>;
+};
+export declare type CreateFeature = {
+    createdAt?: Maybe<Scalars['DateTime']>;
+    description?: Maybe<Scalars['String']>;
+    displayName?: Maybe<Scalars['String']>;
+    environmentId?: Maybe<Scalars['String']>;
+    featureStatus?: Maybe<FeatureStatus>;
+    featureType?: Maybe<FeatureType>;
+    featureUnits?: Maybe<Scalars['String']>;
+    featureUnitsPlural?: Maybe<Scalars['String']>;
+    id?: Maybe<Scalars['String']>;
+    meterType?: Maybe<MeterType>;
+    refId?: Maybe<Scalars['String']>;
+    updatedAt?: Maybe<Scalars['DateTime']>;
+};
+export declare type CreateHook = {
+    createdAt?: Maybe<Scalars['DateTime']>;
+    description?: Maybe<Scalars['String']>;
+    endpoint?: Maybe<Scalars['String']>;
+    environmentId?: Maybe<Scalars['String']>;
+    eventLogTypes?: Maybe<Array<EventLogType>>;
+    id?: Maybe<Scalars['String']>;
+    secretKey?: Maybe<Scalars['String']>;
+    status?: Maybe<HookStatus>;
+};
+export declare type CreateIntegrationInput = {
+    environmentId: Scalars['String'];
+    stripeCredentials?: Maybe<StripeCredentialsInput>;
+    vendorIdentifier: VendorIdentifier;
+    zuoraCredentials?: Maybe<ZuoraCredentialsInput>;
+};
+export declare type CreateManyCustomersInput = {
+    /** Array of records to create */
+    customers: Array<CustomerInput>;
+};
+export declare type CreateManyEnvironmentsInput = {
+    /** Array of records to create */
+    environments: Array<CreateEnvironment>;
+};
+export declare type CreateManyHooksInput = {
+    /** Array of records to create */
+    hooks: Array<CreateHook>;
+};
+export declare type CreateManyIntegrationsInput = {
+    /** Array of records to create */
+    integrations: Array<CreateIntegrationInput>;
+};
+export declare type CreateManyPackageEntitlementsInput = {
+    /** Array of records to create */
+    packageEntitlements: Array<PackageEntitlementInput>;
+};
+export declare type CreateManyProductsInput = {
+    /** Array of records to create */
+    products: Array<ProductCreateInput>;
+};
+export declare type CreateManyPromotionalEntitlementsInput = {
+    /** Array of records to create */
+    promotionalEntitlements: Array<PromotionalEntitlementInput>;
+};
+export declare type CreateOneCustomerInput = {
+    /** The record to create */
+    customer: CustomerInput;
+};
+export declare type CreateOneEnvironmentInput = {
+    /** The record to create */
+    environment: CreateEnvironment;
+};
+export declare type CreateOneFeatureInput = {
+    /** The record to create */
+    feature: CreateFeature;
+};
+export declare type CreateOneHookInput = {
+    /** The record to create */
+    hook: CreateHook;
+};
+export declare type CreateOneIntegrationInput = {
+    /** The record to create */
+    integration: CreateIntegrationInput;
+};
+export declare type CreateOnePackageEntitlementInput = {
+    /** The record to create */
+    packageEntitlement: PackageEntitlementInput;
+};
+export declare type CreateOneProductInput = {
+    /** The record to create */
+    product: ProductCreateInput;
+};
+export declare type CreateOnePromotionalEntitlementInput = {
+    /** The record to create */
+    promotionalEntitlement: PromotionalEntitlementInput;
+};
+/** Currency */
+export declare enum Currency {
+    Usd = "USD"
+}
+export declare type CursorPaging = {
+    /** Paginate after opaque cursor */
+    after?: Maybe<Scalars['ConnectionCursor']>;
+    /** Paginate before opaque cursor */
+    before?: Maybe<Scalars['ConnectionCursor']>;
+    /** Paginate first */
+    first?: Maybe<Scalars['Int']>;
+    /** Paginate last */
+    last?: Maybe<Scalars['Int']>;
+};
+export declare type CustomerDeleteFilter = {
+    and?: Maybe<Array<CustomerDeleteFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    crmId?: Maybe<StringFieldComparison>;
+    email?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    name?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<CustomerDeleteFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type CustomerFilter = {
+    and?: Maybe<Array<CustomerFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    crmId?: Maybe<StringFieldComparison>;
+    email?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    name?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<CustomerFilter>>;
+    promotionalEntitlements?: Maybe<CustomerFilterPromotionalEntitlementFilter>;
+    refId?: Maybe<StringFieldComparison>;
+    subscriptions?: Maybe<CustomerFilterCustomerSubscriptionFilter>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type CustomerFilterCustomerSubscriptionFilter = {
+    and?: Maybe<Array<CustomerFilterCustomerSubscriptionFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    crmId?: Maybe<StringFieldComparison>;
+    endDate?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<CustomerFilterCustomerSubscriptionFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    startDate?: Maybe<DateFieldComparison>;
+    status?: Maybe<SubscriptionStatusFilterComparison>;
+};
+export declare type CustomerFilterPromotionalEntitlementFilter = {
+    and?: Maybe<Array<CustomerFilterPromotionalEntitlementFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<CustomerFilterPromotionalEntitlementFilter>>;
+    status?: Maybe<PromotionalEntitlementStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type CustomerInput = {
+    billingId?: Maybe<Scalars['String']>;
+    crmId?: Maybe<Scalars['String']>;
+    email?: Maybe<Scalars['String']>;
+    environmentId?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    refId: Scalars['String'];
+};
+export declare type CustomerSort = {
+    direction: SortDirection;
+    field: CustomerSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum CustomerSortFields {
+    BillingId = "billingId",
+    CreatedAt = "createdAt",
+    CrmId = "crmId",
+    Email = "email",
+    EnvironmentId = "environmentId",
+    Id = "id",
+    Name = "name",
+    RefId = "refId",
+    UpdatedAt = "updatedAt"
+}
+export declare type CustomerSubscriptionFilter = {
+    addons?: Maybe<CustomerSubscriptionFilterSubscriptionAddonFilter>;
+    and?: Maybe<Array<CustomerSubscriptionFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    crmId?: Maybe<StringFieldComparison>;
+    customer?: Maybe<CustomerSubscriptionFilterCustomerFilter>;
+    endDate?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<CustomerSubscriptionFilter>>;
+    prices?: Maybe<CustomerSubscriptionFilterSubscriptionPriceFilter>;
+    refId?: Maybe<StringFieldComparison>;
+    startDate?: Maybe<DateFieldComparison>;
+    status?: Maybe<SubscriptionStatusFilterComparison>;
+};
+export declare type CustomerSubscriptionFilterCustomerFilter = {
+    and?: Maybe<Array<CustomerSubscriptionFilterCustomerFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    crmId?: Maybe<StringFieldComparison>;
+    email?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    name?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<CustomerSubscriptionFilterCustomerFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type CustomerSubscriptionFilterSubscriptionAddonFilter = {
+    and?: Maybe<Array<CustomerSubscriptionFilterSubscriptionAddonFilter>>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<CustomerSubscriptionFilterSubscriptionAddonFilter>>;
+    quantity?: Maybe<NumberFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type CustomerSubscriptionFilterSubscriptionPriceFilter = {
+    and?: Maybe<Array<CustomerSubscriptionFilterSubscriptionPriceFilter>>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<CustomerSubscriptionFilterSubscriptionPriceFilter>>;
+    updatedAt?: Maybe<DateFieldComparison>;
+    usageLimit?: Maybe<NumberFieldComparison>;
+};
+export declare type CustomerSubscriptionSort = {
+    direction: SortDirection;
+    field: CustomerSubscriptionSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum CustomerSubscriptionSortFields {
+    BillingId = "billingId",
+    CrmId = "crmId",
+    EndDate = "endDate",
+    EnvironmentId = "environmentId",
+    Id = "id",
+    RefId = "refId",
+    StartDate = "startDate",
+    Status = "status"
+}
+export declare type CustomerUpdateFilter = {
+    and?: Maybe<Array<CustomerUpdateFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    crmId?: Maybe<StringFieldComparison>;
+    email?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    name?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<CustomerUpdateFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type DateFieldComparison = {
+    between?: Maybe<DateFieldComparisonBetween>;
+    eq?: Maybe<Scalars['DateTime']>;
+    gt?: Maybe<Scalars['DateTime']>;
+    gte?: Maybe<Scalars['DateTime']>;
+    in?: Maybe<Array<Scalars['DateTime']>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    lt?: Maybe<Scalars['DateTime']>;
+    lte?: Maybe<Scalars['DateTime']>;
+    neq?: Maybe<Scalars['DateTime']>;
+    notBetween?: Maybe<DateFieldComparisonBetween>;
+    notIn?: Maybe<Array<Scalars['DateTime']>>;
+};
+export declare type DateFieldComparisonBetween = {
+    lower: Scalars['DateTime'];
+    upper: Scalars['DateTime'];
+};
+export declare type DefaultTrialConfigInputDto = {
+    duration: Scalars['Float'];
+    units: TrialPeriodUnits;
+};
+export declare type DeleteManyAddonsInput = {
+    /** Filter to find records to delete */
+    filter: AddonDeleteFilter;
+};
+export declare type DeleteManyCustomersInput = {
+    /** Filter to find records to delete */
+    filter: CustomerDeleteFilter;
+};
+export declare type DeleteManyEnvironmentsInput = {
+    /** Filter to find records to delete */
+    filter: EnvironmentDeleteFilter;
+};
+export declare type DeleteManyEventLogsInput = {
+    /** Filter to find records to delete */
+    filter: EventLogDeleteFilter;
+};
+export declare type DeleteManyHooksInput = {
+    /** Filter to find records to delete */
+    filter: HookDeleteFilter;
+};
+export declare type DeleteManyIntegrationsInput = {
+    /** Filter to find records to delete */
+    filter: IntegrationDeleteFilter;
+};
+export declare type DeleteManyPackageEntitlementsInput = {
+    /** Filter to find records to delete */
+    filter: PackageEntitlementDeleteFilter;
+};
+export declare type DeleteManyPlansInput = {
+    /** Filter to find records to delete */
+    filter: PlanDeleteFilter;
+};
+export declare type DeleteManyPricesInput = {
+    /** Filter to find records to delete */
+    filter: PriceDeleteFilter;
+};
+export declare type DeleteManyProductsInput = {
+    /** Filter to find records to delete */
+    filter: ProductDeleteFilter;
+};
+export declare type DeleteManyPromotionalEntitlementsInput = {
+    /** Filter to find records to delete */
+    filter: PromotionalEntitlementDeleteFilter;
+};
+export declare type DeleteOneAddonInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOneCustomerInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOneEnvironmentInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOneEventLogInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOneFeatureInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOneHookInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOneIntegrationInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOnePackageEntitlementInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOnePlanInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOnePriceInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOneProductInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DeleteOnePromotionalEntitlementInput = {
+    /** The id of the record to delete. */
+    id: Scalars['String'];
+};
+export declare type DiscardPackageDraftInput = {
+    environmentId: Scalars['String'];
+    refId: Scalars['String'];
+};
+export declare type EntitlementOptions = {
+    requestedUsage?: Maybe<Scalars['Float']>;
+    shouldTrack?: Maybe<Scalars['Boolean']>;
+};
+/** Entitlement reset period. */
+export declare enum EntitlementResetPeriod {
+    Day = "DAY",
+    Hour = "HOUR",
+    Month = "MONTH",
+    Week = "WEEK"
+}
+export declare type EnvironmentDeleteFilter = {
+    and?: Maybe<Array<EnvironmentDeleteFilter>>;
+    displayName?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<EnvironmentDeleteFilter>>;
+};
+export declare type EnvironmentFilter = {
+    and?: Maybe<Array<EnvironmentFilter>>;
+    displayName?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<EnvironmentFilter>>;
+};
+export declare type EnvironmentSort = {
+    direction: SortDirection;
+    field: EnvironmentSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum EnvironmentSortFields {
+    DisplayName = "displayName",
+    Id = "id"
+}
+export declare type EnvironmentUpdateFilter = {
+    and?: Maybe<Array<EnvironmentUpdateFilter>>;
+    displayName?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<EnvironmentUpdateFilter>>;
+};
+/** error codes */
+export declare enum ErrorCode {
+    AddonNotFound = "AddonNotFound",
+    CheckoutIsNotSupported = "CheckoutIsNotSupported",
+    CustomerNotFound = "CustomerNotFound",
+    DuplicatedEntityNotAllowed = "DuplicatedEntityNotAllowed",
+    EnvironmentMissing = "EnvironmentMissing",
+    FeatureNotFound = "FeatureNotFound",
+    IdentityForbidden = "IdentityForbidden",
+    IntegrityViolation = "IntegrityViolation",
+    InvalidEntitlementResetPeriod = "InvalidEntitlementResetPeriod",
+    InvalidMemberDelete = "InvalidMemberDelete",
+    InvalidUsageValueForIncrementalFeatureError = "InvalidUsageValueForIncrementalFeatureError",
+    MemberInvitationError = "MemberInvitationError",
+    MemberNotFound = "MemberNotFound",
+    MeteringNotAvailableForFeatureType = "MeteringNotAvailableForFeatureType",
+    NoFeatureEntitlementInSubscription = "NoFeatureEntitlementInSubscription",
+    PackageAlreadyPublished = "PackageAlreadyPublished",
+    PlanAlreadyExtended = "PlanAlreadyExtended",
+    PlanNotFound = "PlanNotFound",
+    PlansCircularDependencyError = "PlansCircularDependencyError",
+    PriceNotFound = "PriceNotFound",
+    TrialsNotAllowedInProduct = "TrialsNotAllowedInProduct",
+    UnPublishedPackage = "UnPublishedPackage",
+    UncompatibleSubscriptionAddon = "UncompatibleSubscriptionAddon",
+    UnexpectedError = "UnexpectedError",
+    UnsupportedFeatureType = "UnsupportedFeatureType",
+    UnsupportedVendorIdentifier = "UnsupportedVendorIdentifier"
+}
+export declare type EventLogDeleteFilter = {
+    and?: Maybe<Array<EventLogDeleteFilter>>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<EventLogDeleteFilter>>;
+};
+export declare type EventLogFilter = {
+    and?: Maybe<Array<EventLogFilter>>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<EventLogFilter>>;
+};
+export declare type EventLogSort = {
+    direction: SortDirection;
+    field: EventLogSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum EventLogSortFields {
+    EnvironmentId = "environmentId",
+    Id = "id"
+}
+/** EventLogType */
+export declare enum EventLogType {
+    AddonCreated = "ADDON_CREATED",
+    AddonDeleted = "ADDON_DELETED",
+    AddonUpdated = "ADDON_UPDATED",
+    CustomerCreated = "CUSTOMER_CREATED",
+    CustomerDeleted = "CUSTOMER_DELETED",
+    CustomerUpdated = "CUSTOMER_UPDATED",
+    EntitlementDenied = "ENTITLEMENT_DENIED",
+    EntitlementGranted = "ENTITLEMENT_GRANTED",
+    EntitlementRequested = "ENTITLEMENT_REQUESTED",
+    FeatureCreated = "FEATURE_CREATED",
+    FeatureDeleted = "FEATURE_DELETED",
+    FeatureUpdated = "FEATURE_UPDATED",
+    MeasurementReported = "MEASUREMENT_REPORTED",
+    PackagePublished = "PACKAGE_PUBLISHED",
+    PlanCreated = "PLAN_CREATED",
+    PlanDeleted = "PLAN_DELETED",
+    PlanUpdated = "PLAN_UPDATED",
+    PromotionalEntitlementExpired = "PROMOTIONAL_ENTITLEMENT_EXPIRED",
+    PromotionalEntitlementGranted = "PROMOTIONAL_ENTITLEMENT_GRANTED",
+    PromotionalEntitlementRevoked = "PROMOTIONAL_ENTITLEMENT_REVOKED",
+    PromotionalEntitlementUpdated = "PROMOTIONAL_ENTITLEMENT_UPDATED",
+    SubscriptionCanceled = "SUBSCRIPTION_CANCELED",
+    SubscriptionCreated = "SUBSCRIPTION_CREATED",
+    SubscriptionExpired = "SUBSCRIPTION_EXPIRED",
+    SubscriptionTrialConverted = "SUBSCRIPTION_TRIAL_CONVERTED",
+    SubscriptionTrialEndsSoon = "SUBSCRIPTION_TRIAL_ENDS_SOON",
+    SubscriptionTrialExpired = "SUBSCRIPTION_TRIAL_EXPIRED",
+    SubscriptionTrialStarted = "SUBSCRIPTION_TRIAL_STARTED",
+    SubscriptionUpdated = "SUBSCRIPTION_UPDATED"
+}
+export declare type FeatureFilter = {
+    and?: Maybe<Array<FeatureFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    featureStatus?: Maybe<FeatureStatusFilterComparison>;
+    featureType?: Maybe<FeatureTypeFilterComparison>;
+    id?: Maybe<StringFieldComparison>;
+    meterType?: Maybe<MeterTypeFilterComparison>;
+    or?: Maybe<Array<FeatureFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type FeatureSort = {
+    direction: SortDirection;
+    field: FeatureSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum FeatureSortFields {
+    CreatedAt = "createdAt",
+    Description = "description",
+    DisplayName = "displayName",
+    EnvironmentId = "environmentId",
+    FeatureStatus = "featureStatus",
+    FeatureType = "featureType",
+    Id = "id",
+    MeterType = "meterType",
+    RefId = "refId",
+    UpdatedAt = "updatedAt"
+}
+/** Feature status. */
+export declare enum FeatureStatus {
+    Active = "ACTIVE",
+    New = "NEW",
+    Suspended = "SUSPENDED"
+}
+export declare type FeatureStatusFilterComparison = {
+    eq?: Maybe<FeatureStatus>;
+    gt?: Maybe<FeatureStatus>;
+    gte?: Maybe<FeatureStatus>;
+    iLike?: Maybe<FeatureStatus>;
+    in?: Maybe<Array<FeatureStatus>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<FeatureStatus>;
+    lt?: Maybe<FeatureStatus>;
+    lte?: Maybe<FeatureStatus>;
+    neq?: Maybe<FeatureStatus>;
+    notILike?: Maybe<FeatureStatus>;
+    notIn?: Maybe<Array<FeatureStatus>>;
+    notLike?: Maybe<FeatureStatus>;
+};
+/** The type of the feature */
+export declare enum FeatureType {
+    Boolean = "BOOLEAN",
+    Number = "NUMBER"
+}
+export declare type FeatureTypeFilterComparison = {
+    eq?: Maybe<FeatureType>;
+    gt?: Maybe<FeatureType>;
+    gte?: Maybe<FeatureType>;
+    iLike?: Maybe<FeatureType>;
+    in?: Maybe<Array<FeatureType>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<FeatureType>;
+    lt?: Maybe<FeatureType>;
+    lte?: Maybe<FeatureType>;
+    neq?: Maybe<FeatureType>;
+    notILike?: Maybe<FeatureType>;
+    notIn?: Maybe<Array<FeatureType>>;
+    notLike?: Maybe<FeatureType>;
+};
+export declare type FetchEntitlementQuery = {
+    customerId: Scalars['String'];
+    environmentId?: Maybe<Scalars['String']>;
+    featureId: Scalars['String'];
+    options?: Maybe<EntitlementOptions>;
+};
+export declare type FetchEntitlementsQuery = {
+    customerId: Scalars['String'];
+    environmentId?: Maybe<Scalars['String']>;
+};
+export declare type GetPackageByRefIdInput = {
+    environmentId: Scalars['String'];
+    refId: Scalars['String'];
+    versionNumber?: Maybe<Scalars['Float']>;
+};
+export declare type HookDeleteFilter = {
+    and?: Maybe<Array<HookDeleteFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    endpoint?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<HookDeleteFilter>>;
+    status?: Maybe<HookStatusFilterComparison>;
+};
+export declare type HookFilter = {
+    and?: Maybe<Array<HookFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    endpoint?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<HookFilter>>;
+    status?: Maybe<HookStatusFilterComparison>;
+};
+export declare type HookSort = {
+    direction: SortDirection;
+    field: HookSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum HookSortFields {
+    CreatedAt = "createdAt",
+    Endpoint = "endpoint",
+    EnvironmentId = "environmentId",
+    Id = "id",
+    Status = "status"
+}
+/** HookStatus. */
+export declare enum HookStatus {
+    Active = "ACTIVE",
+    Inactive = "INACTIVE"
+}
+export declare type HookStatusFilterComparison = {
+    eq?: Maybe<HookStatus>;
+    gt?: Maybe<HookStatus>;
+    gte?: Maybe<HookStatus>;
+    iLike?: Maybe<HookStatus>;
+    in?: Maybe<Array<HookStatus>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<HookStatus>;
+    lt?: Maybe<HookStatus>;
+    lte?: Maybe<HookStatus>;
+    neq?: Maybe<HookStatus>;
+    notILike?: Maybe<HookStatus>;
+    notIn?: Maybe<Array<HookStatus>>;
+    notLike?: Maybe<HookStatus>;
+};
+export declare type HookUpdateFilter = {
+    and?: Maybe<Array<HookUpdateFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    endpoint?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<HookUpdateFilter>>;
+    status?: Maybe<HookStatusFilterComparison>;
+};
+export declare type InitiateCheckoutInput = {
+    addons?: Maybe<Array<CheckoutAddonInput>>;
+    billingPeriod: BillingPeriod;
+    cancelUrl: Scalars['String'];
+    customerId: Scalars['String'];
+    environmentId?: Maybe<Scalars['String']>;
+    planId: Scalars['String'];
+    successUrl: Scalars['String'];
+};
+export declare type IntFieldComparison = {
+    between?: Maybe<IntFieldComparisonBetween>;
+    eq?: Maybe<Scalars['Int']>;
+    gt?: Maybe<Scalars['Int']>;
+    gte?: Maybe<Scalars['Int']>;
+    in?: Maybe<Array<Scalars['Int']>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    lt?: Maybe<Scalars['Int']>;
+    lte?: Maybe<Scalars['Int']>;
+    neq?: Maybe<Scalars['Int']>;
+    notBetween?: Maybe<IntFieldComparisonBetween>;
+    notIn?: Maybe<Array<Scalars['Int']>>;
+};
+export declare type IntFieldComparisonBetween = {
+    lower: Scalars['Int'];
+    upper: Scalars['Int'];
+};
+export declare type IntegrationDeleteFilter = {
+    and?: Maybe<Array<IntegrationDeleteFilter>>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<IntegrationDeleteFilter>>;
+    vendorIdentifier?: Maybe<VendorIdentifierFilterComparison>;
+};
+export declare type IntegrationFilter = {
+    and?: Maybe<Array<IntegrationFilter>>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<IntegrationFilter>>;
+    vendorIdentifier?: Maybe<VendorIdentifierFilterComparison>;
+};
+export declare type IntegrationSort = {
+    direction: SortDirection;
+    field: IntegrationSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum IntegrationSortFields {
+    EnvironmentId = "environmentId",
+    Id = "id",
+    VendorIdentifier = "vendorIdentifier"
+}
+export declare type IntegrationUpdateFilter = {
+    and?: Maybe<Array<IntegrationUpdateFilter>>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<IntegrationUpdateFilter>>;
+    vendorIdentifier?: Maybe<VendorIdentifierFilterComparison>;
+};
+export declare type MemberFilter = {
+    and?: Maybe<Array<MemberFilter>>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<MemberFilter>>;
+};
+export declare type MemberSort = {
+    direction: SortDirection;
+    field: MemberSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum MemberSortFields {
+    Id = "id"
+}
+/** Member Status. */
+export declare enum MemberStatus {
+    Invited = "INVITED",
+    Registered = "REGISTERED"
+}
+/** The meter type of the feature */
+export declare enum MeterType {
+    Fluctuating = "Fluctuating",
+    Incremental = "Incremental",
+    None = "None"
+}
+export declare type MeterTypeFilterComparison = {
+    eq?: Maybe<MeterType>;
+    gt?: Maybe<MeterType>;
+    gte?: Maybe<MeterType>;
+    iLike?: Maybe<MeterType>;
+    in?: Maybe<Array<MeterType>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<MeterType>;
+    lt?: Maybe<MeterType>;
+    lte?: Maybe<MeterType>;
+    neq?: Maybe<MeterType>;
+    notILike?: Maybe<MeterType>;
+    notIn?: Maybe<Array<MeterType>>;
+    notLike?: Maybe<MeterType>;
+};
+export declare type MoneyInputDto = {
+    amount: Scalars['Float'];
+    currency?: Maybe<Currency>;
+};
+/** Montly reset period according to configuration */
+export declare enum MonthlyAccordingTo {
+    StartOfTheMonth = "StartOfTheMonth",
+    SubscriptionStart = "SubscriptionStart"
+}
+export declare type MonthlyResetPeriodConfigInput = {
+    accordingTo: MonthlyAccordingTo;
+};
+export declare type NumberFieldComparison = {
+    between?: Maybe<NumberFieldComparisonBetween>;
+    eq?: Maybe<Scalars['Float']>;
+    gt?: Maybe<Scalars['Float']>;
+    gte?: Maybe<Scalars['Float']>;
+    in?: Maybe<Array<Scalars['Float']>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    lt?: Maybe<Scalars['Float']>;
+    lte?: Maybe<Scalars['Float']>;
+    neq?: Maybe<Scalars['Float']>;
+    notBetween?: Maybe<NumberFieldComparisonBetween>;
+    notIn?: Maybe<Array<Scalars['Float']>>;
+};
+export declare type NumberFieldComparisonBetween = {
+    lower: Scalars['Float'];
+    upper: Scalars['Float'];
+};
+export declare type PackageEntitlementDeleteFilter = {
+    and?: Maybe<Array<PackageEntitlementDeleteFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<PackageEntitlementDeleteFilter>>;
+    packageId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type PackageEntitlementFilter = {
+    and?: Maybe<Array<PackageEntitlementFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    feature?: Maybe<PackageEntitlementFilterFeatureFilter>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<PackageEntitlementFilter>>;
+    package?: Maybe<PackageEntitlementFilterPackageDtoFilter>;
+    packageId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type PackageEntitlementFilterFeatureFilter = {
+    and?: Maybe<Array<PackageEntitlementFilterFeatureFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    featureStatus?: Maybe<FeatureStatusFilterComparison>;
+    featureType?: Maybe<FeatureTypeFilterComparison>;
+    id?: Maybe<StringFieldComparison>;
+    meterType?: Maybe<MeterTypeFilterComparison>;
+    or?: Maybe<Array<PackageEntitlementFilterFeatureFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type PackageEntitlementFilterPackageDtoFilter = {
+    and?: Maybe<Array<PackageEntitlementFilterPackageDtoFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isLatest?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<PackageEntitlementFilterPackageDtoFilter>>;
+    productId?: Maybe<StringFieldComparison>;
+    refId?: Maybe<StringFieldComparison>;
+    status?: Maybe<PackageStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+    versionNumber?: Maybe<IntFieldComparison>;
+};
+export declare type PackageEntitlementInput = {
+    description?: Maybe<Scalars['String']>;
+    environmentId: Scalars['String'];
+    featureId: Scalars['String'];
+    hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
+    monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
+    packageId: Scalars['String'];
+    resetPeriod?: Maybe<EntitlementResetPeriod>;
+    usageLimit?: Maybe<Scalars['Float']>;
+    weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
+};
+export declare type PackageEntitlementSort = {
+    direction: SortDirection;
+    field: PackageEntitlementSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum PackageEntitlementSortFields {
+    CreatedAt = "createdAt",
+    EnvironmentId = "environmentId",
+    Id = "id",
+    PackageId = "packageId",
+    UpdatedAt = "updatedAt"
+}
+export declare type PackageEntitlementUpdateFilter = {
+    and?: Maybe<Array<PackageEntitlementUpdateFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<PackageEntitlementUpdateFilter>>;
+    packageId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type PackageEntitlementUpdateInput = {
+    description?: Maybe<Scalars['String']>;
+    hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
+    monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
+    resetPeriod?: Maybe<EntitlementResetPeriod>;
+    usageLimit?: Maybe<Scalars['Float']>;
+    weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
+};
+export declare type PackagePublishInput = {
+    id: Scalars['ID'];
+    migrationType: PublishMigrationType;
+};
+/** Package status. */
+export declare enum PackageStatus {
+    Draft = "DRAFT",
+    Published = "PUBLISHED"
+}
+export declare type PackageStatusFilterComparison = {
+    eq?: Maybe<PackageStatus>;
+    gt?: Maybe<PackageStatus>;
+    gte?: Maybe<PackageStatus>;
+    iLike?: Maybe<PackageStatus>;
+    in?: Maybe<Array<PackageStatus>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<PackageStatus>;
+    lt?: Maybe<PackageStatus>;
+    lte?: Maybe<PackageStatus>;
+    neq?: Maybe<PackageStatus>;
+    notILike?: Maybe<PackageStatus>;
+    notIn?: Maybe<Array<PackageStatus>>;
+    notLike?: Maybe<PackageStatus>;
+};
+export declare type PlanCreateInput = {
+    billingId?: Maybe<Scalars['String']>;
+    description?: Maybe<Scalars['String']>;
+    displayName: Scalars['String'];
+    environmentId: Scalars['String'];
+    parentPlanId?: Maybe<Scalars['String']>;
+    productId: Scalars['String'];
+    refId: Scalars['String'];
+    status?: Maybe<PackageStatus>;
+};
+export declare type PlanDeleteFilter = {
+    and?: Maybe<Array<PlanDeleteFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isLatest?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<PlanDeleteFilter>>;
+    productId?: Maybe<StringFieldComparison>;
+    refId?: Maybe<StringFieldComparison>;
+    status?: Maybe<PackageStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+    versionNumber?: Maybe<IntFieldComparison>;
+};
+export declare type PlanFilter = {
+    and?: Maybe<Array<PlanFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isLatest?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<PlanFilter>>;
+    productId?: Maybe<StringFieldComparison>;
+    refId?: Maybe<StringFieldComparison>;
+    status?: Maybe<PackageStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+    versionNumber?: Maybe<IntFieldComparison>;
+};
+export declare type PlanSort = {
+    direction: SortDirection;
+    field: PlanSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum PlanSortFields {
+    BillingId = "billingId",
+    CreatedAt = "createdAt",
+    Description = "description",
+    DisplayName = "displayName",
+    EnvironmentId = "environmentId",
+    Id = "id",
+    IsLatest = "isLatest",
+    ProductId = "productId",
+    RefId = "refId",
+    Status = "status",
+    UpdatedAt = "updatedAt",
+    VersionNumber = "versionNumber"
+}
+export declare type PlanUpdateInput = {
+    billingId?: Maybe<Scalars['String']>;
+    defaultTrialConfig?: Maybe<DefaultTrialConfigInputDto>;
+    description?: Maybe<Scalars['String']>;
+    displayName?: Maybe<Scalars['String']>;
+    id: Scalars['String'];
+    parentPlanId?: Maybe<Scalars['String']>;
+    status?: Maybe<PackageStatus>;
+};
+export declare type PriceCreateInput = {
+    billingModel: BillingModel;
+    billingPeriod: BillingPeriod;
+    environmentId: Scalars['String'];
+    featureId?: Maybe<Scalars['String']>;
+    packageId: Scalars['String'];
+    price: MoneyInputDto;
+};
+export declare type PriceDeleteFilter = {
+    and?: Maybe<Array<PriceDeleteFilter>>;
+    billingModel?: Maybe<BillingModelFilterComparison>;
+    billingPeriod?: Maybe<BillingPeriodFilterComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<PriceDeleteFilter>>;
+};
+export declare type PriceFilter = {
+    and?: Maybe<Array<PriceFilter>>;
+    billingModel?: Maybe<BillingModelFilterComparison>;
+    billingPeriod?: Maybe<BillingPeriodFilterComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<PriceFilter>>;
+    package?: Maybe<PriceFilterPackageDtoFilter>;
+};
+export declare type PriceFilterPackageDtoFilter = {
+    and?: Maybe<Array<PriceFilterPackageDtoFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isLatest?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<PriceFilterPackageDtoFilter>>;
+    productId?: Maybe<StringFieldComparison>;
+    refId?: Maybe<StringFieldComparison>;
+    status?: Maybe<PackageStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+    versionNumber?: Maybe<IntFieldComparison>;
+};
+export declare type PriceSort = {
+    direction: SortDirection;
+    field: PriceSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum PriceSortFields {
+    BillingModel = "billingModel",
+    BillingPeriod = "billingPeriod",
+    Id = "id"
+}
+export declare type PriceUpdateInput = {
+    billingModel: BillingModel;
+    billingPeriod: BillingPeriod;
+    environmentId: Scalars['String'];
+    featureId?: Maybe<Scalars['String']>;
+    id: Scalars['String'];
+    packageId: Scalars['String'];
+    price: MoneyInputDto;
+};
+export declare type ProductCreateInput = {
+    description?: Maybe<Scalars['String']>;
+    displayName?: Maybe<Scalars['String']>;
+    environmentId: Scalars['String'];
+    refId: Scalars['String'];
+};
+export declare type ProductDeleteFilter = {
+    and?: Maybe<Array<ProductDeleteFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isDefaultProduct?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<ProductDeleteFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type ProductFilter = {
+    and?: Maybe<Array<ProductFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isDefaultProduct?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<ProductFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type ProductSort = {
+    direction: SortDirection;
+    field: ProductSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum ProductSortFields {
+    CreatedAt = "createdAt",
+    Description = "description",
+    DisplayName = "displayName",
+    EnvironmentId = "environmentId",
+    Id = "id",
+    IsDefaultProduct = "isDefaultProduct",
+    RefId = "refId",
+    UpdatedAt = "updatedAt"
+}
+export declare type ProductUpdateFilter = {
+    and?: Maybe<Array<ProductUpdateFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isDefaultProduct?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<ProductUpdateFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type ProductUpdateInput = {
+    description?: Maybe<Scalars['String']>;
+    displayName?: Maybe<Scalars['String']>;
+    downgradePlanId?: Maybe<Scalars['String']>;
+    trialSetup?: Maybe<TrialSetup>;
+};
+export declare type PromotionalEntitlementDeleteFilter = {
+    and?: Maybe<Array<PromotionalEntitlementDeleteFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<PromotionalEntitlementDeleteFilter>>;
+    status?: Maybe<PromotionalEntitlementStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type PromotionalEntitlementFilter = {
+    and?: Maybe<Array<PromotionalEntitlementFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<PromotionalEntitlementFilter>>;
+    status?: Maybe<PromotionalEntitlementStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type PromotionalEntitlementInput = {
+    customerId: Scalars['String'];
+    description?: Maybe<Scalars['String']>;
+    endDate?: Maybe<Scalars['DateTime']>;
+    environmentId: Scalars['String'];
+    featureId: Scalars['String'];
+    hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
+    isVisible: Scalars['Boolean'];
+    monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
+    period: PromotionalEntitlementPeriod;
+    resetPeriod?: Maybe<EntitlementResetPeriod>;
+    usageLimit?: Maybe<Scalars['Float']>;
+    weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
+};
+/** Promotional entitlement duration */
+export declare enum PromotionalEntitlementPeriod {
+    Custom = "CUSTOM",
+    Lifetime = "LIFETIME",
+    OneMonth = "ONE_MONTH",
+    OneWeek = "ONE_WEEK",
+    OneYear = "ONE_YEAR",
+    SixMonth = "SIX_MONTH"
+}
+export declare type PromotionalEntitlementSort = {
+    direction: SortDirection;
+    field: PromotionalEntitlementSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum PromotionalEntitlementSortFields {
+    CreatedAt = "createdAt",
+    EnvironmentId = "environmentId",
+    Id = "id",
+    Status = "status",
+    UpdatedAt = "updatedAt"
+}
+/** Promotional entitlement status */
+export declare enum PromotionalEntitlementStatus {
+    Active = "Active",
+    Expired = "Expired",
+    Paused = "Paused"
+}
+export declare type PromotionalEntitlementStatusFilterComparison = {
+    eq?: Maybe<PromotionalEntitlementStatus>;
+    gt?: Maybe<PromotionalEntitlementStatus>;
+    gte?: Maybe<PromotionalEntitlementStatus>;
+    iLike?: Maybe<PromotionalEntitlementStatus>;
+    in?: Maybe<Array<PromotionalEntitlementStatus>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<PromotionalEntitlementStatus>;
+    lt?: Maybe<PromotionalEntitlementStatus>;
+    lte?: Maybe<PromotionalEntitlementStatus>;
+    neq?: Maybe<PromotionalEntitlementStatus>;
+    notILike?: Maybe<PromotionalEntitlementStatus>;
+    notIn?: Maybe<Array<PromotionalEntitlementStatus>>;
+    notLike?: Maybe<PromotionalEntitlementStatus>;
+};
+export declare type PromotionalEntitlementUpdateFilter = {
+    and?: Maybe<Array<PromotionalEntitlementUpdateFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<PromotionalEntitlementUpdateFilter>>;
+    status?: Maybe<PromotionalEntitlementStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type PromotionalEntitlementUpdateInput = {
+    description?: Maybe<Scalars['String']>;
+    endDate?: Maybe<Scalars['DateTime']>;
+    hasUnlimitedUsage?: Maybe<Scalars['Boolean']>;
+    isVisible: Scalars['Boolean'];
+    monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
+    period: PromotionalEntitlementPeriod;
+    resetPeriod?: Maybe<EntitlementResetPeriod>;
+    usageLimit?: Maybe<Scalars['Float']>;
+    weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
+};
+/** PublishMigrationType */
+export declare enum PublishMigrationType {
+    AllCustomers = "ALL_CUSTOMERS",
+    NewCustomers = "NEW_CUSTOMERS"
+}
+export declare type RemoveAccountFromEnvironmentInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveAccountFromFeatureInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveAccountFromHookInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveAccountFromIntegrationInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveAccountFromMemberInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveAddonFromSubscriptionAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveAddonsFromCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type RemoveBasePlanFromPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveCompatibleAddonsFromPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type RemoveCustomerFromCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveCustomerFromPromotionalEntitlementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveCustomerFromUsageMeasurementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveDowngradePlanFromProductInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromCustomerInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromEventLogInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromFeatureInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromHookInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromIntegrationInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromProductInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveEnvironmentFromUsageMeasurementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveFeatureFromPackageEntitlementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveFeatureFromPromotionalEntitlementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveFeatureFromUsageMeasurementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemovePackageFromPackageEntitlementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemovePackageFromPriceInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemovePlanFromCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemovePriceFromSubscriptionAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemovePriceFromSubscriptionPriceInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemovePricesFromAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type RemovePricesFromCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type RemovePricesFromPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type RemoveSubscriptionFromSubscriptionAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveSubscriptionFromSubscriptionPriceInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type RemoveUserFromMemberInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetAccountOnEnvironmentInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetAccountOnFeatureInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetAccountOnHookInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetAccountOnIntegrationInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetAccountOnMemberInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetAddonOnSubscriptionAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetAddonsOnCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type SetApiKeysOnEnvironmentInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type SetBasePlanOnPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetCompatibleAddonsOnPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type SetCustomerOnCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetCustomerOnPromotionalEntitlementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetCustomerOnUsageMeasurementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetDowngradePlanOnProductInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnCustomerInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnEventLogInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnFeatureInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnHookInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnIntegrationInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnProductInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetEnvironmentOnUsageMeasurementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetFeatureOnPackageEntitlementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetFeatureOnPromotionalEntitlementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetFeatureOnUsageMeasurementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetPackageOnPackageEntitlementInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetPackageOnPriceInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetPlanOnCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetPriceOnSubscriptionAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetPriceOnSubscriptionPriceInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetPricesOnAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type SetPricesOnCustomerSubscriptionInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type SetPricesOnPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type SetProductOnAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetProductOnPlanInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetSubscriptionOnSubscriptionAddonInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetSubscriptionOnSubscriptionPriceInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+export declare type SetSubscriptionsOnCustomerInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The ids of the relations. */
+    relationIds: Array<Scalars['String']>;
+};
+export declare type SetUserOnMemberInput = {
+    /** The id of the record. */
+    id: Scalars['String'];
+    /** The id of relation. */
+    relationId: Scalars['String'];
+};
+/** Sort Directions */
+export declare enum SortDirection {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+/** Sort Nulls Options */
+export declare enum SortNulls {
+    NullsFirst = "NULLS_FIRST",
+    NullsLast = "NULLS_LAST"
+}
+export declare type StringFieldComparison = {
+    eq?: Maybe<Scalars['String']>;
+    gt?: Maybe<Scalars['String']>;
+    gte?: Maybe<Scalars['String']>;
+    iLike?: Maybe<Scalars['String']>;
+    in?: Maybe<Array<Scalars['String']>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<Scalars['String']>;
+    lt?: Maybe<Scalars['String']>;
+    lte?: Maybe<Scalars['String']>;
+    neq?: Maybe<Scalars['String']>;
+    notILike?: Maybe<Scalars['String']>;
+    notIn?: Maybe<Array<Scalars['String']>>;
+    notLike?: Maybe<Scalars['String']>;
+};
+export declare type StripeCredentialsInput = {
+    accountId?: Maybe<Scalars['String']>;
+    authorizationCode: Scalars['String'];
+    isTestMode: Scalars['Boolean'];
+};
+export declare type SubscriptionAddonFilter = {
+    addon?: Maybe<SubscriptionAddonFilterAddonFilter>;
+    and?: Maybe<Array<SubscriptionAddonFilter>>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<SubscriptionAddonFilter>>;
+    price?: Maybe<SubscriptionAddonFilterPriceFilter>;
+    quantity?: Maybe<NumberFieldComparison>;
+    subscription?: Maybe<SubscriptionAddonFilterCustomerSubscriptionFilter>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type SubscriptionAddonFilterAddonFilter = {
+    and?: Maybe<Array<SubscriptionAddonFilterAddonFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    isLatest?: Maybe<BooleanFieldComparison>;
+    or?: Maybe<Array<SubscriptionAddonFilterAddonFilter>>;
+    productId?: Maybe<StringFieldComparison>;
+    refId?: Maybe<StringFieldComparison>;
+    status?: Maybe<PackageStatusFilterComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+    versionNumber?: Maybe<IntFieldComparison>;
+};
+export declare type SubscriptionAddonFilterCustomerSubscriptionFilter = {
+    and?: Maybe<Array<SubscriptionAddonFilterCustomerSubscriptionFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    crmId?: Maybe<StringFieldComparison>;
+    endDate?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<SubscriptionAddonFilterCustomerSubscriptionFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    startDate?: Maybe<DateFieldComparison>;
+    status?: Maybe<SubscriptionStatusFilterComparison>;
+};
+export declare type SubscriptionAddonFilterPriceFilter = {
+    and?: Maybe<Array<SubscriptionAddonFilterPriceFilter>>;
+    billingModel?: Maybe<BillingModelFilterComparison>;
+    billingPeriod?: Maybe<BillingPeriodFilterComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<SubscriptionAddonFilterPriceFilter>>;
+};
+export declare type SubscriptionAddonInput = {
+    addonId: Scalars['String'];
+    billingPeriod: BillingPeriod;
+    quantity?: Maybe<Scalars['Int']>;
+};
+export declare type SubscriptionAddonSort = {
+    direction: SortDirection;
+    field: SubscriptionAddonSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum SubscriptionAddonSortFields {
+    Id = "id",
+    Quantity = "quantity",
+    UpdatedAt = "updatedAt"
+}
+export declare type SubscriptionInput = {
+    addons?: Maybe<Array<SubscriptionAddonInput>>;
+    billingId?: Maybe<Scalars['String']>;
+    billingPeriod: BillingPeriod;
+    crmId?: Maybe<Scalars['String']>;
+    customerId: Scalars['String'];
+    endDate?: Maybe<Scalars['DateTime']>;
+    environmentId: Scalars['String'];
+    isTrial?: Maybe<Scalars['Boolean']>;
+    planId: Scalars['String'];
+    priceUnitAmount?: Maybe<Scalars['Float']>;
+    refId?: Maybe<Scalars['String']>;
+    startDate: Scalars['DateTime'];
+};
+export declare type SubscriptionMigrationInput = {
+    subscriptionId: Scalars['String'];
+};
+export declare type SubscriptionPriceFilter = {
+    and?: Maybe<Array<SubscriptionPriceFilter>>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<SubscriptionPriceFilter>>;
+    price?: Maybe<SubscriptionPriceFilterPriceFilter>;
+    subscription?: Maybe<SubscriptionPriceFilterCustomerSubscriptionFilter>;
+    updatedAt?: Maybe<DateFieldComparison>;
+    usageLimit?: Maybe<NumberFieldComparison>;
+};
+export declare type SubscriptionPriceFilterCustomerSubscriptionFilter = {
+    and?: Maybe<Array<SubscriptionPriceFilterCustomerSubscriptionFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    crmId?: Maybe<StringFieldComparison>;
+    endDate?: Maybe<DateFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<SubscriptionPriceFilterCustomerSubscriptionFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    startDate?: Maybe<DateFieldComparison>;
+    status?: Maybe<SubscriptionStatusFilterComparison>;
+};
+export declare type SubscriptionPriceFilterPriceFilter = {
+    and?: Maybe<Array<SubscriptionPriceFilterPriceFilter>>;
+    billingModel?: Maybe<BillingModelFilterComparison>;
+    billingPeriod?: Maybe<BillingPeriodFilterComparison>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<SubscriptionPriceFilterPriceFilter>>;
+};
+export declare type SubscriptionPriceSort = {
+    direction: SortDirection;
+    field: SubscriptionPriceSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum SubscriptionPriceSortFields {
+    Id = "id",
+    UpdatedAt = "updatedAt",
+    UsageLimit = "usageLimit"
+}
+/** Subscription status */
+export declare enum SubscriptionStatus {
+    Active = "ACTIVE",
+    Expired = "EXPIRED",
+    Inactive = "INACTIVE",
+    InTrial = "IN_TRIAL"
+}
+export declare type SubscriptionStatusFilterComparison = {
+    eq?: Maybe<SubscriptionStatus>;
+    gt?: Maybe<SubscriptionStatus>;
+    gte?: Maybe<SubscriptionStatus>;
+    iLike?: Maybe<SubscriptionStatus>;
+    in?: Maybe<Array<SubscriptionStatus>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<SubscriptionStatus>;
+    lt?: Maybe<SubscriptionStatus>;
+    lte?: Maybe<SubscriptionStatus>;
+    neq?: Maybe<SubscriptionStatus>;
+    notILike?: Maybe<SubscriptionStatus>;
+    notIn?: Maybe<Array<SubscriptionStatus>>;
+    notLike?: Maybe<SubscriptionStatus>;
+};
+export declare type TestHookInput = {
+    endpointUrl: Scalars['String'];
+    hookEventType: EventLogType;
+};
+/** day or month. */
+export declare enum TrialPeriodUnits {
+    Day = "DAY",
+    Month = "MONTH"
+}
+export declare enum TrialSetup {
+    CancelSubscription = "CANCEL_SUBSCRIPTION",
+    DowngradeToFree = "DOWNGRADE_TO_FREE",
+    NoTrials = "NO_TRIALS"
+}
+export declare type UpdateCustomer = {
+    billingId?: Maybe<Scalars['String']>;
+    billingLinkUrl?: Maybe<Scalars['String']>;
+    createdAt?: Maybe<Scalars['DateTime']>;
+    crmId?: Maybe<Scalars['String']>;
+    email?: Maybe<Scalars['String']>;
+    environmentId?: Maybe<Scalars['String']>;
+    id?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    refId?: Maybe<Scalars['String']>;
+    updatedAt?: Maybe<Scalars['DateTime']>;
+};
+export declare type UpdateEnvironment = {
+    description?: Maybe<Scalars['String']>;
+    displayName?: Maybe<Scalars['String']>;
+    id?: Maybe<Scalars['String']>;
+    slug?: Maybe<Scalars['String']>;
+};
+export declare type UpdateFeature = {
+    createdAt?: Maybe<Scalars['DateTime']>;
+    description?: Maybe<Scalars['String']>;
+    displayName?: Maybe<Scalars['String']>;
+    environmentId?: Maybe<Scalars['String']>;
+    featureStatus?: Maybe<FeatureStatus>;
+    featureType?: Maybe<FeatureType>;
+    featureUnits?: Maybe<Scalars['String']>;
+    featureUnitsPlural?: Maybe<Scalars['String']>;
+    id?: Maybe<Scalars['String']>;
+    meterType?: Maybe<MeterType>;
+    refId?: Maybe<Scalars['String']>;
+    updatedAt?: Maybe<Scalars['DateTime']>;
+};
+export declare type UpdateHook = {
+    createdAt?: Maybe<Scalars['DateTime']>;
+    description?: Maybe<Scalars['String']>;
+    endpoint?: Maybe<Scalars['String']>;
+    environmentId?: Maybe<Scalars['String']>;
+    eventLogTypes?: Maybe<Array<EventLogType>>;
+    id?: Maybe<Scalars['String']>;
+    secretKey?: Maybe<Scalars['String']>;
+    status?: Maybe<HookStatus>;
+};
+export declare type UpdateIntegrationInput = {
+    stripeCredentials?: Maybe<StripeCredentialsInput>;
+    vendorIdentifier: VendorIdentifier;
+    zuoraCredentials?: Maybe<ZuoraCredentialsInput>;
+};
+export declare type UpdateManyCustomersInput = {
+    /** Filter used to find fields to update */
+    filter: CustomerUpdateFilter;
+    /** The update to apply to all records found using the filter */
+    update: UpdateCustomer;
+};
+export declare type UpdateManyEnvironmentsInput = {
+    /** Filter used to find fields to update */
+    filter: EnvironmentUpdateFilter;
+    /** The update to apply to all records found using the filter */
+    update: UpdateEnvironment;
+};
+export declare type UpdateManyHooksInput = {
+    /** Filter used to find fields to update */
+    filter: HookUpdateFilter;
+    /** The update to apply to all records found using the filter */
+    update: UpdateHook;
+};
+export declare type UpdateManyIntegrationsInput = {
+    /** Filter used to find fields to update */
+    filter: IntegrationUpdateFilter;
+    /** The update to apply to all records found using the filter */
+    update: UpdateIntegrationInput;
+};
+export declare type UpdateManyPackageEntitlementsInput = {
+    /** Filter used to find fields to update */
+    filter: PackageEntitlementUpdateFilter;
+    /** The update to apply to all records found using the filter */
+    update: PackageEntitlementUpdateInput;
+};
+export declare type UpdateManyProductsInput = {
+    /** Filter used to find fields to update */
+    filter: ProductUpdateFilter;
+    /** The update to apply to all records found using the filter */
+    update: ProductUpdateInput;
+};
+export declare type UpdateManyPromotionalEntitlementsInput = {
+    /** Filter used to find fields to update */
+    filter: PromotionalEntitlementUpdateFilter;
+    /** The update to apply to all records found using the filter */
+    update: PromotionalEntitlementUpdateInput;
+};
+export declare type UpdateOneCustomerInput = {
+    /** The id of the record to update */
+    id: Scalars['String'];
+    /** The update to apply. */
+    update: UpdateCustomer;
+};
+export declare type UpdateOneEnvironmentInput = {
+    /** The id of the record to update */
+    id: Scalars['String'];
+    /** The update to apply. */
+    update: UpdateEnvironment;
+};
+export declare type UpdateOneFeatureInput = {
+    /** The id of the record to update */
+    id: Scalars['String'];
+    /** The update to apply. */
+    update: UpdateFeature;
+};
+export declare type UpdateOneHookInput = {
+    /** The id of the record to update */
+    id: Scalars['String'];
+    /** The update to apply. */
+    update: UpdateHook;
+};
+export declare type UpdateOneIntegrationInput = {
+    /** The id of the record to update */
+    id: Scalars['String'];
+    /** The update to apply. */
+    update: UpdateIntegrationInput;
+};
+export declare type UpdateOnePackageEntitlementInput = {
+    /** The id of the record to update */
+    id: Scalars['String'];
+    /** The update to apply. */
+    update: PackageEntitlementUpdateInput;
+};
+export declare type UpdateOneProductInput = {
+    /** The id of the record to update */
+    id: Scalars['String'];
+    /** The update to apply. */
+    update: ProductUpdateInput;
+};
+export declare type UpdateOnePromotionalEntitlementInput = {
+    /** The id of the record to update */
+    id: Scalars['String'];
+    /** The update to apply. */
+    update: PromotionalEntitlementUpdateInput;
+};
+export declare type UsageHistoryInput = {
+    customerRefId: Scalars['String'];
+    endDate?: Maybe<Scalars['DateTime']>;
+    environmentId?: Maybe<Scalars['String']>;
+    featureRefId: Scalars['String'];
+    monthlyResetPeriodConfiguration?: Maybe<MonthlyResetPeriodConfigInput>;
+    resetPeriod?: Maybe<EntitlementResetPeriod>;
+    startDate: Scalars['DateTime'];
+    weeklyResetPeriodConfiguration?: Maybe<WeeklyResetPeriodConfigInput>;
+};
+export declare type UsageMeasurementCreateInput = {
+    createdAt?: Maybe<Scalars['DateTime']>;
+    customerId: Scalars['String'];
+    environmentId?: Maybe<Scalars['String']>;
+    featureId: Scalars['String'];
+    value: Scalars['Float'];
+};
+export declare type UsageMeasurementFilter = {
+    and?: Maybe<Array<UsageMeasurementFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    customer?: Maybe<UsageMeasurementFilterCustomerFilter>;
+    environmentId?: Maybe<StringFieldComparison>;
+    feature?: Maybe<UsageMeasurementFilterFeatureFilter>;
+    id?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<UsageMeasurementFilter>>;
+};
+export declare type UsageMeasurementFilterCustomerFilter = {
+    and?: Maybe<Array<UsageMeasurementFilterCustomerFilter>>;
+    billingId?: Maybe<StringFieldComparison>;
+    createdAt?: Maybe<DateFieldComparison>;
+    crmId?: Maybe<StringFieldComparison>;
+    email?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    id?: Maybe<StringFieldComparison>;
+    name?: Maybe<StringFieldComparison>;
+    or?: Maybe<Array<UsageMeasurementFilterCustomerFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type UsageMeasurementFilterFeatureFilter = {
+    and?: Maybe<Array<UsageMeasurementFilterFeatureFilter>>;
+    createdAt?: Maybe<DateFieldComparison>;
+    description?: Maybe<StringFieldComparison>;
+    displayName?: Maybe<StringFieldComparison>;
+    environmentId?: Maybe<StringFieldComparison>;
+    featureStatus?: Maybe<FeatureStatusFilterComparison>;
+    featureType?: Maybe<FeatureTypeFilterComparison>;
+    id?: Maybe<StringFieldComparison>;
+    meterType?: Maybe<MeterTypeFilterComparison>;
+    or?: Maybe<Array<UsageMeasurementFilterFeatureFilter>>;
+    refId?: Maybe<StringFieldComparison>;
+    updatedAt?: Maybe<DateFieldComparison>;
+};
+export declare type UsageMeasurementSort = {
+    direction: SortDirection;
+    field: UsageMeasurementSortFields;
+    nulls?: Maybe<SortNulls>;
+};
+export declare enum UsageMeasurementSortFields {
+    CreatedAt = "createdAt",
+    EnvironmentId = "environmentId",
+    Id = "id"
+}
+export declare enum VendorIdentifier {
+    Stripe = "STRIPE",
+    Zuora = "ZUORA"
+}
+export declare type VendorIdentifierFilterComparison = {
+    eq?: Maybe<VendorIdentifier>;
+    gt?: Maybe<VendorIdentifier>;
+    gte?: Maybe<VendorIdentifier>;
+    iLike?: Maybe<VendorIdentifier>;
+    in?: Maybe<Array<VendorIdentifier>>;
+    is?: Maybe<Scalars['Boolean']>;
+    isNot?: Maybe<Scalars['Boolean']>;
+    like?: Maybe<VendorIdentifier>;
+    lt?: Maybe<VendorIdentifier>;
+    lte?: Maybe<VendorIdentifier>;
+    neq?: Maybe<VendorIdentifier>;
+    notILike?: Maybe<VendorIdentifier>;
+    notIn?: Maybe<Array<VendorIdentifier>>;
+    notLike?: Maybe<VendorIdentifier>;
+};
+/** Weekly reset period according to configuration */
+export declare enum WeeklyAccordingTo {
+    EveryFriday = "EveryFriday",
+    EveryMonday = "EveryMonday",
+    EverySaturday = "EverySaturday",
+    EverySunday = "EverySunday",
+    EveryThursday = "EveryThursday",
+    EveryTuesday = "EveryTuesday",
+    EveryWednesday = "EveryWednesday",
+    SubscriptionStart = "SubscriptionStart"
+}
+export declare type WeeklyResetPeriodConfigInput = {
+    accordingTo: WeeklyAccordingTo;
+};
+export declare type ZuoraCredentialsInput = {
+    baseUrl: Scalars['String'];
+    clientId: Scalars['String'];
+    clientSecret: Scalars['String'];
+};
+export declare type GetEnvironmentQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export declare type GetEnvironmentQuery = {
+    __typename?: 'Query';
+    currentEnvironment: string;
+};
+export declare type EntitlementQueryVariables = Exact<{
+    query: FetchEntitlementQuery;
+}>;
+export declare type EntitlementQuery = {
+    __typename?: 'Query';
+    entitlement: {
+        __typename?: 'Entitlement';
+    } & EntitlementFragment;
+};
+export declare type CachedEntitlementsQueryVariables = Exact<{
+    query: FetchEntitlementsQuery;
+}>;
+export declare type CachedEntitlementsQuery = {
+    __typename?: 'Query';
+    cachedEntitlements: Array<{
+        __typename?: 'Entitlement';
+    } & EntitlementFragment>;
+};
+export declare type CreateUsageMeasurementMutationVariables = Exact<{
+    usageMeasurement: UsageMeasurementCreateInput;
+}>;
+export declare type CreateUsageMeasurementMutation = {
+    __typename?: 'Mutation';
+    createUsageMeasurement: {
+        __typename?: 'UsageMeasurement';
+        id: string;
+    };
+};
+export declare type FeatureFragment = {
+    __typename?: 'EntitlementFeature';
+    featureType: FeatureType;
+    meterType?: MeterType | null | undefined;
+    featureUnits?: string | null | undefined;
+    featureUnitsPlural?: string | null | undefined;
+    refId: string;
+};
+export declare type EntitlementFragment = {
+    __typename?: 'Entitlement';
+    isGranted: boolean;
+    accessDeniedReason?: AccessDeniedReason | null | undefined;
+    customerId?: string | null | undefined;
+    usageLimit?: number | null | undefined;
+    hasUnlimitedUsage: boolean;
+    currentUsage?: number | null | undefined;
+    requestedUsage?: number | null | undefined;
+    nextResetDate?: any | null | undefined;
+    feature?: ({
+        __typename?: 'EntitlementFeature';
+    } & FeatureFragment) | null | undefined;
+};
+export declare type EntitlementsUpdatedSubscriptionVariables = Exact<{
+    [key: string]: never;
+}>;
+export declare type EntitlementsUpdatedSubscription = {
+    __typename?: 'Subscription';
+    entitlementsUpdated: {
+        __typename?: 'EntitlementsUpdated';
+        customerId: string;
+        entitlements: Array<{
+            __typename?: 'Entitlement';
+        } & EntitlementFragment>;
+    };
+};
+export declare type UsageUpdatedSubscriptionVariables = Exact<{
+    [key: string]: never;
+}>;
+export declare type UsageUpdatedSubscription = {
+    __typename?: 'Subscription';
+    usageUpdated: {
+        __typename?: 'UsageUpdated';
+        usage: {
+            __typename?: 'UsageMeasurementUpdated';
+            customerId: string;
+            featureId: string;
+            currentUsage: number;
+            nextResetDate?: number | null | undefined;
+        };
+        entitlement: {
+            __typename?: 'Entitlement';
+        } & EntitlementFragment;
+    };
+};
+export declare type CreateCustomerMutationVariables = Exact<{
+    input: CreateOneCustomerInput;
+}>;
+export declare type CreateCustomerMutation = {
+    __typename?: 'Mutation';
+    createOneCustomer: {
+        __typename?: 'Customer';
+        refId: string;
+    };
+};
+export declare type CreateSubscriptionMutationVariables = Exact<{
+    input: SubscriptionInput;
+}>;
+export declare type CreateSubscriptionMutation = {
+    __typename?: 'Mutation';
+    createSubscription: {
+        __typename?: 'CustomerSubscription';
+        plan: {
+            __typename?: 'Plan';
+            refId: string;
+        };
+        addons?: Array<{
+            __typename?: 'SubscriptionAddon';
+            addon: {
+                __typename?: 'Addon';
+                refId: string;
+            };
+        }> | null | undefined;
+        customer: {
+            __typename?: 'Customer';
+            refId: string;
+        };
+    };
+};
+export declare type InitiateCheckoutMutationVariables = Exact<{
+    input: InitiateCheckoutInput;
+}>;
+export declare type InitiateCheckoutMutation = {
+    __typename?: 'Mutation';
+    initiateCheckout: {
+        __typename?: 'Checkout';
+        checkoutUrl: string;
+        checkoutBillingId: string;
+    };
+};