@wix/auto_sdk_benefit-programs_pools 1.0.0

package/build/es/src/benefit-programs-v1-pool-pools.types.d.ts

@@ -0,0 +1,1434 @@
+export interface Pool {
+    /**
+     * Pool ID.
+     * @readonly
+     */
+    id?: string | null;
+    /**
+     * Revision number, which increments by 1 each time the pool is updated.
+     * To prevent conflicting changes, the current revision must be passed when updating the pool.
+     *
+     * Ignored when creating a pool.
+     * @readonly
+     */
+    revision?: string | null;
+    /**
+     * Date and time the pool was created.
+     * @readonly
+     */
+    createdDate?: Date | null;
+    /**
+     * Date and time the pool was updated.
+     * @readonly
+     */
+    updatedDate?: Date | null;
+    /**
+     * Pool definition from which this benefit pool was created.
+     * @readonly
+     */
+    poolDefinitionId?: string | null;
+    /**
+     * Program definition from which this benefit pool was provisioned.
+     * @readonly
+     */
+    programDefinitionId?: string | null;
+    /**
+     * ID of the program to which this benefit pool is associated.
+     * @readonly
+     */
+    programId?: string | null;
+    /**
+     * Benefit pool status.
+     * @readonly
+     */
+    status?: PoolStatus;
+    /** Benefit pool owner. */
+    beneficiary?: CommonIdentificationData;
+    /**
+     * Benefit pool information.
+     *
+     * Includes the item, policy, and credit configurations.
+     */
+    details?: Details;
+    /**
+     * Pool name.
+     *
+     * It's recommended to keep the same as the associated pool definition's `displayName`.
+     */
+    displayName?: string;
+    /** External system that is the source of the program creation. For example, `wix-pricing-plans`, `wix-loyalty`. */
+    namespace?: string | null;
+    /**
+     * Custom field data for the pool object.
+     * [Extended fields](https://dev.wix.com/docs/build-apps/develop-your-app/extensions/backend-extensions/schema-plugins/about-schema-plugin-extensions) must be configured in the app dashboard before they can be accessed with API calls.
+     */
+    extendedFields?: ExtendedFields;
+    /**
+     * Program definition information.
+     * @readonly
+     */
+    programDefinition?: ProgramDefinitionInfo;
+    /**
+     * Program information.
+     * @readonly
+     */
+    program?: ProgramInfo;
+    /**
+     * Version of the associated pool definition at the this benefit pool was created.
+     *
+     * `poolDefinition.revision`.
+     * @readonly
+     */
+    poolDefinitionRevision?: string | null;
+    /**
+     * Number of times this benefit pool has been renewed.
+     * @readonly
+     */
+    renewalCount?: number | null;
+}
+export declare enum PoolStatus {
+    UNDEFINED = "UNDEFINED",
+    /** Active benefit pool. */
+    ACTIVE = "ACTIVE",
+    /** Paused benefit pool. */
+    PAUSED = "PAUSED",
+    /**
+     * Inactive benefit pool.
+     *
+     * Benefits can't be redeemed or reserved.
+     */
+    ENDED = "ENDED",
+    /** Process state of activating the benefit pool's program. */
+    PROVISIONING = "PROVISIONING",
+    /**
+     * Process state of renewing the benefits.
+     * Typically at the start of a new benefit renewal cycle.
+     * Result of calling Renew Program API.
+     */
+    RENEWING = "RENEWING"
+}
+export interface CommonIdentificationData extends CommonIdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+}
+/** @oneof */
+export interface CommonIdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+}
+export declare enum IdentityType {
+    /** Unknown type. This value is not used. */
+    UNKNOWN = "UNKNOWN",
+    /** A site visitor who has not logged in. */
+    ANONYMOUS_VISITOR = "ANONYMOUS_VISITOR",
+    /** A logged-in site member. */
+    MEMBER = "MEMBER",
+    /** A Wix account holder, such as a site owner or contributor. */
+    WIX_USER = "WIX_USER"
+}
+export interface Details {
+    /** Array of benefits, each containing price and policy settings specific to that benefit within the pool. */
+    benefits?: Benefit[];
+    /**
+     * Settings that control the initial credits and renewal cycle configurations of the benefit pool.
+     *
+     * Default: Benefits may be redeemed without limit.
+     */
+    creditConfiguration?: CreditConfiguration;
+    /**
+     * Defines the redemption policy for a benefit pool. This includes specifying the days of the week and the hours during which the benefits can be redeemed.
+     *
+     * Policy types may be either:
+     *
+     * + FIXED INTERVALS: Specifies the timing during the day.
+     *
+     * + RATE LIMITED: Specifies how many times the benefit can be redeemed within a given renewal cycle.
+     *
+     * Each selected policy type must have its corresponding policy options. For example, the `fixedInterval` type requires `fixedIntervalOptions` to be included in the parameters.
+     *
+     * This parameter is the default policy for all the benefits in the benefit pool. It may be overridden for specific benefits in the `details.benefits.policyExpression` parameter.
+     */
+    policyExpression?: PolicyExpression;
+    /** Additional info set by the benefit provider. */
+    additionalData?: Record<string, any> | null;
+}
+export interface Benefit {
+    /**
+     * An unique identifier for a pool benefit.
+     *
+     * This key is consistent across the pool definition and all its associated benefit pools.
+     */
+    benefitKey?: string;
+    /**
+     * Represents the associated benefit item that belongs to a benefit pool.
+     *
+     * This ID is returned when calling Create Item.
+     *
+     * It is used to link the specific benefit item to its corresponding location within the benefit pool, ensuring proper association between the item and the pool definition.
+     * @readonly
+     */
+    itemSetId?: string | null;
+    /**
+     * Price of the benefit item as expressed in credits.
+     * Represents the cost to redeem the benefit.
+     *
+     * Don't set a price if the `details.creditConfiguration` is empty. Since the benefits have an unlimited redemption limit, they can't have an associated price.
+     */
+    price?: string | null;
+    /**
+     * Defines the redemption policy for a specific benefit. This includes specifying the days of the week and the hours during which the benefits can be redeemed.
+     *
+     * Overrides the default policies in `benefit.details`.
+     */
+    policyExpression?: PolicyExpression;
+    /** Additional info that was set by the benefit provider. */
+    additionalData?: Record<string, any> | null;
+    /** ID of the app providing the benefit. */
+    providerAppId?: string | null;
+    /** Benefit display name. */
+    displayName?: string | null;
+    /** Benefit description. */
+    description?: string | null;
+}
+export interface PolicyExpression extends PolicyExpressionExpressionOneOf {
+    /** Negates the expression. */
+    operatorNotOptions?: PolicyExpressionNot;
+    /** Combines the expressions with an `AND` operator. */
+    operatorAndOptions?: PolicyExpressionAnd;
+    /** Combines the expressions with an `OR` operator. */
+    operatorOrOptions?: PolicyExpressionOr;
+    /** Defines policy terms for benefit redemption. */
+    policyOptions?: Policy;
+    /**
+     * Declare type of policy conditions or settings to use. Use together with the associated policy options to construct policy terms.
+     *
+     * Different operators can be used to combine multiple policy terms.
+     */
+    type?: PolicyExpressionType;
+}
+/** @oneof */
+export interface PolicyExpressionExpressionOneOf {
+    /** Negates the expression. */
+    operatorNotOptions?: PolicyExpressionNot;
+    /** Combines the expressions with an `AND` operator. */
+    operatorAndOptions?: PolicyExpressionAnd;
+    /** Combines the expressions with an `OR` operator. */
+    operatorOrOptions?: PolicyExpressionOr;
+    /** Defines policy terms for benefit redemption. */
+    policyOptions?: Policy;
+}
+export declare enum PolicyExpressionType {
+    UNKNOWN = "UNKNOWN",
+    /** Use with associated `operatorNotOptions`. */
+    OPERATOR_NOT = "OPERATOR_NOT",
+    /** Use with associated `operatorAndOptions`. */
+    OPERATOR_AND = "OPERATOR_AND",
+    /** Use with associated `operatorOrOptions`. */
+    OPERATOR_OR = "OPERATOR_OR",
+    /** Use with associated `policyOptions` to define a policy. */
+    POLICY = "POLICY"
+}
+export interface PolicyExpressionNot {
+    /** Specify policy terms where none of specified policy conditions should be met. Must specify an object with an `expressions` property. */
+    expression?: PolicyExpression;
+}
+export interface PolicyExpressionAnd {
+    /** Specify policy terms where all policy conditions must be met. Must specify an object with an `expressions` property. */
+    expressions?: PolicyExpression[];
+}
+export interface PolicyExpressionOr {
+    /** Specify policy terms where at least one of the possible specified policy conditions is met. Must specify an object with an `expressions` property. */
+    expressions?: PolicyExpression[];
+}
+export interface Policy extends PolicyPolicyOneOf {
+    /** Defines the timing of benefit policy redemption for specific days or hours. */
+    fixedIntervalOptions?: FixedIntervalPolicy;
+    /** Sets a limit on the number of times a benefit can be redeemed within a given renewal cycle. */
+    rateLimitedOptions?: RateLimitedPolicy;
+    /** Custom policy definition that is controlled by the CustomPolicyProvider. */
+    customOptions?: CustomPolicy;
+    /** Specific policy setting. Use together with its associated policy type options. For example, a fixed interval policy type should include a `fixedIntervalOptions` parameter. */
+    type?: Type;
+}
+/** @oneof */
+export interface PolicyPolicyOneOf {
+    /** Defines the timing of benefit policy redemption for specific days or hours. */
+    fixedIntervalOptions?: FixedIntervalPolicy;
+    /** Sets a limit on the number of times a benefit can be redeemed within a given renewal cycle. */
+    rateLimitedOptions?: RateLimitedPolicy;
+    /** Custom policy definition that is controlled by the CustomPolicyProvider. */
+    customOptions?: CustomPolicy;
+}
+export declare enum Type {
+    /** Unknown policy type. */
+    UNKNOWN = "UNKNOWN",
+    /** Fixed interval policy type. */
+    FIXED_INTERVAL = "FIXED_INTERVAL",
+    /** Rate limited policy type. */
+    RATE_LIMITED = "RATE_LIMITED",
+    CUSTOM = "CUSTOM"
+}
+export interface FixedIntervalPolicy {
+    /** Weekday that this interval starts from. If this field is set, then `toWeekDay` must also be set. */
+    fromWeekDay?: WeekDay;
+    /** Weekday that this interval ends at. If this field is set, then `fromWeekDay` must also be set. */
+    toWeekDay?: WeekDay;
+    /** Hour that this interval starts from. If this field is set, then `toHour` must also be set. */
+    fromHour?: number | null;
+    /** Hour that this interval ends at. If this field is set, then `fromHour` must also be set. */
+    toHour?: number | null;
+    /** Minute that this interval starts from. If this field is set, then `toMinute` must also be set. */
+    fromMinute?: number | null;
+    /** Minute that this interval ends at. If this field is set, then `fromMinute` must also be set. */
+    toMinute?: number | null;
+}
+export declare enum WeekDay {
+    /** Unknown weekday. */
+    UNKNOWN = "UNKNOWN",
+    /** Monday. */
+    MONDAY = "MONDAY",
+    /** Tuesday. */
+    TUESDAY = "TUESDAY",
+    /** Wednesday. */
+    WEDNESDAY = "WEDNESDAY",
+    /** Thursday. */
+    THURSDAY = "THURSDAY",
+    /** Friday. */
+    FRIDAY = "FRIDAY",
+    /** Saturday. */
+    SATURDAY = "SATURDAY",
+    /** Sunday. */
+    SUNDAY = "SUNDAY"
+}
+export interface RateLimitedPolicy extends RateLimitedPolicyPeriodOneOf {
+    /**
+     * Defines the timing of benefit policy redemption for specific days or hours.
+     *
+     * Used to set the timing policy for a maximum limit of redemptions.
+     */
+    fixedIntervalOptions?: FixedIntervalPolicy;
+    /** Maximum number of times benefit can be redeemed per renewal cycle. */
+    times?: number;
+    /** Specific method of setting the benefit limit. `FIXED_INTERVAL` type must be used with its corresponding `fixIntervalPolicyOptions` parameter. */
+    type?: RateLimitedPolicyType;
+}
+/** @oneof */
+export interface RateLimitedPolicyPeriodOneOf {
+    /**
+     * Defines the timing of benefit policy redemption for specific days or hours.
+     *
+     * Used to set the timing policy for a maximum limit of redemptions.
+     */
+    fixedIntervalOptions?: FixedIntervalPolicy;
+}
+export declare enum RateLimitedPolicyType {
+    /** Unknown rate limit method. */
+    UNKNOWN = "UNKNOWN",
+    /** Fixed interval rate limit. The intervals are set using `fixIntervalPolicyOptions`. */
+    FIXED_INTERVAL = "FIXED_INTERVAL",
+    /** Rate limit is set with `times` field above. */
+    PER_CYCLE = "PER_CYCLE"
+}
+/** Custom policy as implemented by the Entitlement Policy Provider */
+export interface CustomPolicy {
+    /** References a specific custom policy on the provider's system */
+    id?: string;
+    /** Custom policy provider id */
+    appId?: string | null;
+    /** Additional info for this custom policy. It's going to be passed to the policy provider during eligibility checks */
+    additionalData?: Record<string, any> | null;
+}
+export interface CreditConfiguration {
+    /** The initial total amount of credits available in this benefit pool. */
+    amount?: string;
+    /** Rollover configuration. */
+    rolloverConfiguration?: RolloverConfiguration;
+    /** Display name of the unit. */
+    unitDisplayName?: string | null;
+}
+export interface RolloverConfiguration {
+    /** Determine whether unused credits are rolled over to the new cycle. */
+    enabled?: boolean | null;
+    /**
+     * The maximum amount of credits that can be transferred to the next benefit renewal cycle.
+     *
+     * If current balance exceeds this cap, no credits will transfer into the next renewal cycle until the balance is within the allowable limit.
+     */
+    balanceCap?: string | null;
+}
+export interface ExtendedFields {
+    /**
+     * Extended field data. Each key corresponds to the namespace of the app that created the extended fields.
+     * The value of each key is structured according to the schema defined when the extended fields were configured.
+     *
+     * You can only access fields for which you have the appropriate permissions.
+     *
+     * Learn more about [extended fields](https://dev.wix.com/docs/rest/articles/getting-started/extended-fields).
+     */
+    namespaces?: Record<string, Record<string, any>>;
+}
+export interface ProgramDefinitionInfo {
+    /**
+     * ID of the program definition that provisioned the program associated with this benefit pool.
+     * @readonly
+     */
+    id?: string;
+    /**
+     * External ID of the program definition that provisioned this program.
+     *
+     * This identifies the source program definition in the external system.
+     * @readonly
+     */
+    externalId?: string | null;
+}
+export interface ProgramInfo {
+    /**
+     * ID of the program associated with this benefit pool.
+     * @readonly
+     */
+    id?: string;
+    /**
+     * External ID of the program associated with this benefit pool.
+     *
+     * This identifies the source program in the external system.
+     * @readonly
+     */
+    externalId?: string | null;
+}
+export declare enum PoolOrigin {
+    /** Unknown pool origin. */
+    UNKNOWN = "UNKNOWN",
+    /** Benefit pool created by a program provision. */
+    PROVISION = "PROVISION",
+    /** Benefit pool was created when pool definition was added to program definition. */
+    CASCADE = "CASCADE"
+}
+export interface PoolProvisioned {
+    /** Pool which has been provisioned */
+    pool?: Pool;
+}
+export interface PoolRenewed {
+    /** Pool which has been granted */
+    pool?: Pool;
+}
+export interface BenefitRedeemed {
+    /** Pool which has been redeemed */
+    pool?: Pool;
+    /** Details of the redemption */
+    redemptionDetails?: RedemptionDetails;
+}
+export interface RedemptionDetails {
+    /** Id of the redemption transaction */
+    transactionId?: string;
+    /** Reference of the item that is being redeemed */
+    itemReference?: ItemReference;
+    /** Number of of items to redeem */
+    itemCount?: number;
+    /**
+     * Date at which the item will be used. Target date does not necessarily equal the redemption date. Credits are redeemed immediately.
+     * This date is only used for validations that may be performed by entitlement providers
+     */
+    targetDate?: Date | null;
+    /** Idempotency key */
+    idempotencyKey?: string;
+    /** Additional info provided during redemption */
+    additionalData?: Record<string, any> | null;
+    /** Beneficiary of the entitlement */
+    beneficiary?: CommonIdentificationData;
+}
+export interface ItemReference {
+    /** External ID of the item. */
+    externalId?: string;
+    /** Item category. */
+    category?: string;
+    /** ID of the application providing the benefits. */
+    providerAppId?: string;
+}
+export interface PoolPaused {
+    /** Pool which has been paused */
+    pool?: Pool;
+}
+export interface PoolResumed {
+    /** Pool which has been resumed */
+    pool?: Pool;
+}
+export interface PoolEnded {
+    /** Pool which has been ended */
+    pool?: Pool;
+}
+export interface BenefitReserved {
+    /** Pool which was used to perform this transaction */
+    pool?: Pool;
+    /** Details of the redemption */
+    redemptionDetails?: RedemptionDetails;
+}
+export interface BenefitReservationCanceled {
+    /** Pool which was used to perform this transaction */
+    pool?: Pool;
+    /** Id of the canceled reservation transaction */
+    transactionId?: string;
+}
+export interface BenefitReservationReleased {
+    /** Pool which was used to perform this transaction */
+    pool?: Pool;
+    /** Id of the released reservation transaction */
+    transactionId?: string;
+}
+export interface CreatePoolRequest {
+    /** Pool to be created. */
+    pool?: Pool;
+}
+export interface CreatePoolResponse {
+    /** Created pool. */
+    pool?: Pool;
+}
+export interface GetPoolRequest {
+    /** ID of the pool to retrieve. */
+    poolId: string;
+}
+export interface GetPoolResponse {
+    /** Retrieved pool. */
+    pool?: Pool;
+}
+export interface UpdatePoolRequest {
+    /** Pool to be updated. */
+    pool: Pool;
+}
+export interface UpdatePoolResponse {
+    /** Updated pool. */
+    pool?: Pool;
+}
+export interface DeletePoolRequest {
+    /** ID of the pool to delete. */
+    poolId?: string;
+}
+export interface DeletePoolResponse {
+}
+export interface QueryPoolsRequest {
+    /** Query to select pools. */
+    query: CursorQuery;
+}
+export interface CursorQuery extends CursorQueryPagingMethodOneOf {
+    /** Cursor token pointing to a page of results. Not used in the first request. Following requests use the cursor token and not `filter` or `sort`. */
+    cursorPaging?: CursorPaging;
+    /**
+     * Filter object in the following format:
+     * `"filter" : {
+     * "fieldName1": "value1",
+     * "fieldName2":{"$operator":"value2"}
+     * }`
+     * Example of operators: `$eq`, `$ne`, `$lt`, `$lte`, `$gt`, `$gte`, `$in`, `$hasSome`, `$hasAll`, `$startsWith`, `$contains`
+     */
+    filter?: Record<string, any> | null;
+    /**
+     * Sort object in the following format:
+     * `[{"fieldName":"sortField1","order":"ASC"},{"fieldName":"sortField2","order":"DESC"}]`
+     */
+    sort?: Sorting[];
+}
+/** @oneof */
+export interface CursorQueryPagingMethodOneOf {
+    /** Cursor token pointing to a page of results. Not used in the first request. Following requests use the cursor token and not `filter` or `sort`. */
+    cursorPaging?: CursorPaging;
+}
+export interface Sorting {
+    /** Name of the field to sort by. */
+    fieldName?: string;
+    /** Sort order. */
+    order?: SortOrder;
+}
+export declare enum SortOrder {
+    /** Ascending sort order. */
+    ASC = "ASC",
+    /** Descending sort order. */
+    DESC = "DESC"
+}
+export interface CursorPaging {
+    /** Maximum number of items to return in the results. */
+    limit?: number | null;
+    /**
+     * Pointer to the next or previous page in the list of results.
+     *
+     * Pass the relevant cursor token from the `pagingMetadata` object in the previous call's response.
+     * Not relevant for the first request.
+     */
+    cursor?: string | null;
+}
+export interface QueryPoolsResponse {
+    /** List of pools. */
+    pools?: Pool[];
+    /** Metadata for the paginated results. */
+    metadata?: CursorPagingMetadata;
+}
+export interface CursorPagingMetadata {
+    /** Number of items returned in the response. */
+    count?: number | null;
+    /** Cursor strings that point to the next page, previous page, or both. */
+    cursors?: Cursors;
+    /**
+     * Whether there are more pages to retrieve following the current page.
+     *
+     * + `true`: Another page of results can be retrieved.
+     * + `false`: This is the last page.
+     */
+    hasNext?: boolean | null;
+}
+export interface Cursors {
+    /** Cursor string pointing to the next page in the list of results. */
+    next?: string | null;
+    /** Cursor pointing to the previous page in the list of results. */
+    prev?: string | null;
+}
+export interface RedeemBenefitRequest {
+    /** ID of the benefit pool being redeemed. */
+    poolId: string;
+    /** Reference of the benefit item that is being redeemed. */
+    itemReference: ItemReference;
+    /**
+     * Key of the specific benefit to be redeemed.
+     *
+     * This needs to be specified to ensure the correct benefit is redeemed.
+     */
+    benefitKey: string;
+    /** Number of of items to redeem. */
+    count?: number;
+    /**
+     * Date when the benefit item will be used.
+     *
+     * While credit balance is adjusted immediately upon the redemption request, the target date may be set for a later time than the date of the request.
+     *
+     * Used for the app providing the benefit items to manage the logistics associated with the item.
+     */
+    targetDate?: Date | null;
+    /**
+     * Unique identifier, generated by the client.
+     * Used to recognize repeated attempts to make the same request.
+     */
+    idempotencyKey: string;
+    /** Additional information. */
+    additionalData?: Record<string, any> | null;
+    /** Benefit pool owner. */
+    beneficiary?: CommonIdentificationData;
+    /**
+     * Module that is the source of the benefit pool creation.
+     *
+     * Must match the previously defined namespace in the associated pool definition.
+     */
+    namespace: string;
+}
+export interface RedeemBenefitResponse {
+    /** Id of the resulting transaction. */
+    transactionId?: string;
+}
+export interface NotEnoughBalance {
+    /** Pool ID */
+    poolId?: string;
+    /** Item reference */
+    itemReference?: ItemReference;
+    /** Price of the item expressed in credits */
+    availableBalance?: string;
+    /** Price of the item expressed in credits */
+    requestedBalance?: string;
+}
+export interface PolicyExpressionEvaluatedToFalse {
+    /** Pool ID */
+    poolId?: string;
+    /** Item reference */
+    itemReference?: ItemReference;
+    /** Failure details */
+    failureDetails?: FailureDetails[];
+}
+export interface FailureDetails {
+    /** Failure code */
+    code?: string;
+    /** Failure message */
+    message?: string | null;
+    /** Policy id */
+    policyId?: string | null;
+    /** App that owns the policy */
+    appId?: string | null;
+    /** Information provided by the policy */
+    errorData?: Record<string, any> | null;
+}
+export interface PoolNotActive {
+    /** Pool ID */
+    poolId?: string;
+    /** Pool status */
+    poolStatus?: PoolStatus;
+}
+export interface PoolNotFound {
+    /** Pool ID */
+    poolId?: string;
+}
+export interface BenefitAlreadyRedeemed {
+    /** Pool ID */
+    poolId?: string;
+    /** Idempotency key of the request that failed */
+    idempotencyKey?: string;
+}
+export interface BenefitNotFound {
+    /** Pool ID */
+    poolId?: string;
+    /** Key of the referenced benefit, if provided */
+    benefitKey?: string | null;
+}
+export interface ReserveBenefitRequest {
+    /** Id of the pool that is being redeemed from */
+    poolId?: string;
+    /** Reference of the item that is being redeemed. */
+    itemReference?: ItemReference;
+    /**
+     * Key of the benefit to be redeemed, associated with a particular benefit.
+     *
+     * This key must be specified to ensure the correct benefit is redeemed.
+     *
+     * Default: The first eligible benefit in the benefit pool will be redeemed.
+     */
+    benefitKey?: string | null;
+    /** Number of items to redeem. */
+    count?: number;
+    /**
+     * Date when the benefit item will be used.
+     *
+     * While the credit balance is adjusted immediately upon the redemption request, the target date may be set for a later time than the date of the request.
+     *
+     * Used for the app providing the benefit items to manage the logistics associated with the item.
+     */
+    targetDate?: Date | null;
+    /** Idempotency key */
+    idempotencyKey?: string;
+    /** Additional info */
+    additionalData?: Record<string, any> | null;
+    /** Benefit pool owner. */
+    beneficiary?: CommonIdentificationData;
+    /**
+     * Module that is the source of the benefit pool creation.
+     *
+     * This value must correspond with the previously defined namespace established when creating the associated pool definition.
+     *
+     * It ensures efficient processing and management of pools and benefits.
+     */
+    namespace?: string;
+}
+export interface ReserveBenefitResponse {
+    /** Id of the transaction that was created as a result of this request */
+    transactionId?: string;
+}
+export interface CancelBenefitReservationRequest {
+    /** Id of the transaction that was created as a result of this request */
+    transactionId?: string;
+}
+export interface CancelBenefitReservationResponse {
+    /** Id of the transaction that was created as a result of this request */
+    transactionId?: string;
+}
+export interface ReleaseBenefitReservationRequest {
+    /** Id of the transaction that was created as a result of this request */
+    transactionId?: string;
+}
+export interface ReleaseBenefitReservationResponse {
+    /** Id of the transaction that was created as a result of this request */
+    transactionId?: string;
+}
+export interface CheckBenefitEligibilityRequest {
+    /** ID of the benefit pool to check eligibility against. */
+    poolId: string;
+    /**
+     * Key of the benefit to be redeemed, associated with a particular benefit.
+     *
+     * This key must be specified to ensure the correct benefit is redeemed.
+     *
+     * Default: The first eligible benefit in the benefit pool will be redeemed.
+     */
+    benefitKey?: string | null;
+    /** Reference of the item for which to check benefit's eligibility. */
+    itemReference: ItemReference;
+    /**
+     * Number of items for which to check eligibility.
+     *
+     * This number will be evaluated against the policies and credit balance of the benefit pool to determine if sufficient funds are met for the specified number of items.
+     */
+    count?: number;
+    /**
+     * Date when the benefit item will be used.
+     *
+     * While credit balance is adjusted immediately upon the redemption request, the target date may be set for a later time than the date of the request.
+     *
+     * Used for the app providing the benefit items to manage the logistics associated with the item.
+     */
+    targetDate?: Date | null;
+    /** Additional info */
+    additionalData?: Record<string, any> | null;
+    /** Benefit pool owner. */
+    beneficiary?: CommonIdentificationData;
+    /**
+     * Module that is the source of the benefit pool creation.
+     *
+     * This value must correspond with the previously defined namespace established when creating the associated pool definition.
+     *
+     * It ensures efficient processing and management of pools and benefits.
+     */
+    namespace: string;
+}
+export interface CheckBenefitEligibilityResponse {
+    /**
+     * Result of the eligibility check. Includes the benefit's eligibility.
+     *
+     * If the benefit is not eligible for redemption, provides a reason for ineligiblity.
+     */
+    result?: EligibilityCheckResult;
+}
+export interface EligibilityCheckResult extends EligibilityCheckResultResultOneOf {
+    /** Set when eligibility check passed. */
+    eligibleOptions?: Eligible;
+    /** Set when balance is insufficient. */
+    notEnoughBalanceOptions?: NotEnoughBalance;
+    /** Set when policy expression evaluates to false. */
+    policyExpressionEvaluatedToFalseOptions?: PolicyExpressionEvaluatedToFalse;
+    /** Set when pool is inactive. */
+    poolNotActiveOptions?: PoolNotActive;
+    /** Set when benefit can't be found. */
+    benefitNotFoundOptions?: BenefitNotFound;
+    /** Set when pool can't be found. */
+    poolNotFoundOptions?: PoolNotFound;
+    /** Eligibility status. */
+    type?: EligibilityCheckResultType;
+}
+/** @oneof */
+export interface EligibilityCheckResultResultOneOf {
+    /** Set when eligibility check passed. */
+    eligibleOptions?: Eligible;
+    /** Set when balance is insufficient. */
+    notEnoughBalanceOptions?: NotEnoughBalance;
+    /** Set when policy expression evaluates to false. */
+    policyExpressionEvaluatedToFalseOptions?: PolicyExpressionEvaluatedToFalse;
+    /** Set when pool is inactive. */
+    poolNotActiveOptions?: PoolNotActive;
+    /** Set when benefit can't be found. */
+    benefitNotFoundOptions?: BenefitNotFound;
+    /** Set when pool can't be found. */
+    poolNotFoundOptions?: PoolNotFound;
+}
+export interface EligibleBenefit {
+    /**
+     * Pool ID
+     * @readonly
+     */
+    poolId?: string;
+    /** Key of the specific benefit. */
+    benefitKey?: string;
+    /** Item reference */
+    itemReference?: ItemReference;
+    /** Price of the item expressed in credits */
+    price?: string | null;
+}
+export declare enum EligibilityCheckResultType {
+    /** Unknown pool eligibility. */
+    UNKNOWN = "UNKNOWN",
+    /** Eligible pool. */
+    ELIGIBLE = "ELIGIBLE",
+    /** Insufficient pool balance. */
+    NOT_ENOUGH_BALANCE = "NOT_ENOUGH_BALANCE",
+    /** Policy is false. */
+    POLICY_EXPRESSION_EVALUATED_TO_FALSE = "POLICY_EXPRESSION_EVALUATED_TO_FALSE",
+    /** Inactive pool. */
+    POOL_NOT_ACTIVE = "POOL_NOT_ACTIVE",
+    /** Invalid benefit. */
+    BENEFIT_NOT_FOUND = "BENEFIT_NOT_FOUND",
+    /** Invalid pool. */
+    POOL_NOT_FOUND = "POOL_NOT_FOUND"
+}
+export interface Eligible {
+    /** Eligible benefits. */
+    eligibleBenefits?: EligibleBenefit[];
+}
+export interface BulkCheckBenefitEligibilityRequest {
+    /** Benefits to check eligibility. */
+    benefitSelectors?: BenefitSelector[];
+    /**
+     * Module that is the source of the benefit pool creation.
+     *
+     * This value must correspond with the previously defined namespace established when creating the associated pool definition.
+     *
+     * It ensures efficient processing and management of pools and benefits.
+     */
+    namespace: string;
+    /** Benefit pool owner. */
+    beneficiary?: CommonIdentificationData;
+}
+export interface BenefitSelector {
+    /** ID of the pool to check for eligibility. */
+    poolId?: string;
+    /** ID of the benefit to check for eligibility. */
+    benefitKey?: string | null;
+    /** Reference of the item for which to check benefit's eligibility. */
+    itemReference?: ItemReference;
+    /**
+     * Number of items for which to check eligibility.
+     *
+     * This number will be evaluated against the policies and credit balance of the benefit pool to determine if sufficient funds are met for the specified number of items.
+     */
+    count?: number;
+    /**
+     * Date when the benefit item will be used.
+     *
+     * While credit balance is adjusted immediately upon the redemption request, the target date may be set for a later time than the date of the request.
+     *
+     * Used for the app providing the benefit items to manage the logistics associated with the item.
+     */
+    targetDate?: Date | null;
+    /** Additional info */
+    additionalData?: Record<string, any> | null;
+}
+export interface BulkCheckBenefitEligibilityResponse {
+    /** List of results for pool benefit eligibility. */
+    results?: BulkEligibilityCheckResult[];
+}
+export interface BulkEligibilityCheckResult {
+    /** Retrieved information for each benefit pool. */
+    benefitSelector?: BenefitSelector;
+    /** Outcome of the eligibility check. */
+    result?: EligibilityCheckResult;
+}
+export interface GetEligibleBenefitsRequest {
+    /** Reference of the item for which all eligible pools will be returned. */
+    itemReference: ItemReference;
+    /**
+     * Number of items for which to check eligibility.
+     *
+     * This number will be evaluated against the policies and credit balance of the benefit pool to determine if sufficient funds are met for the specified number of items.
+     */
+    count?: number;
+    /**
+     * Date when the benefit item will be used.
+     *
+     * While credit balance is adjusted immediately upon the redemption request, the target date may be set for a later time than the date of the request.
+     *
+     * Used for the app providing the benefit items to manage the logistics associated with the item.
+     */
+    targetDate?: Date | null;
+    /** Additional information. */
+    additionalData?: Record<string, any> | null;
+    /** Benefit pool owner. */
+    beneficiary?: CommonIdentificationData;
+    /**
+     * Module that is the source of the benefit pool creation.
+     *
+     * This value must correspond with the previously defined namespace established when creating the associated pool definition.
+     *
+     * It ensures efficient processing and management of pools and benefits.
+     */
+    namespace: string;
+}
+export interface GetEligibleBenefitsResponse {
+    /** Retrieved eligible benefits. */
+    eligibleBenefits?: EligibleBenefit[];
+}
+export interface ListPoolsRequest {
+    /** The filter */
+    filter?: Filter;
+    /** Cursor paging */
+    cursorPaging?: CursorPaging;
+}
+export declare enum ListPoolsRequestType {
+    UNKNOWN_FILTER = "UNKNOWN_FILTER",
+    BY_ITEM_REFERENCE = "BY_ITEM_REFERENCE"
+}
+export interface ByItemReference {
+    /** A list of filters */
+    filters?: ByItemReferenceFilter[];
+    /** Beneficiary of the pool */
+    beneficiary?: CommonIdentificationData;
+    /** Returns pools that are in the following statuses */
+    poolStatuses?: PoolStatus[];
+}
+export interface ByItemReferenceFilter {
+    /** Reference of the item */
+    itemReference?: ItemReference;
+}
+export interface Filter extends FilterFilterOneOf {
+    /** A list of filters by reference */
+    byItemReferenceOptions?: ByItemReference;
+    /** Type of the filter */
+    type?: ListPoolsRequestType;
+    /**
+     * Module that is the source of the benefit pool creation.
+     *
+     * This value must correspond with the previously defined namespace established when creating the associated pool definition.
+     *
+     * It ensures efficient processing and management of pools and benefits.
+     */
+    namespace?: string;
+}
+/** @oneof */
+export interface FilterFilterOneOf {
+    /** A list of filters by reference */
+    byItemReferenceOptions?: ByItemReference;
+}
+export interface ListPoolsResponse {
+    /** The retrieved pools */
+    pools?: PoolWithItems[];
+    /** Paging information */
+    metadata?: CursorPagingMetadata;
+}
+export interface PoolWithItems {
+    /** The pool */
+    pool?: Pool;
+    /** The items in the pool */
+    itemReference?: ItemReference[];
+}
+export interface BulkUpdatePoolsRequest {
+    /** Pools to update. */
+    pools?: MaskedPool[];
+    /**
+     * Whether to return the full pool definition entities.
+     *
+     * Default: `false`
+     */
+    returnEntity?: boolean;
+}
+export interface MaskedPool {
+    /** Pool to update. */
+    pool?: Pool;
+    /** Explicit list of fields to update. */
+    fieldMask?: string[];
+}
+export interface BulkUpdatePoolsResponse {
+    /**
+     * List of results for each pool.
+     *
+     * Includes the pool, pool metadata, and whether the update was successful.
+     */
+    results?: BulkPoolResult[];
+    /** Bulk action metadata. */
+    bulkActionMetadata?: BulkActionMetadata;
+}
+export interface BulkPoolResult {
+    /** Pool metadata. */
+    poolMetadata?: ItemMetadata;
+    /** Only exists if `returnEntity` was set to true in the request */
+    pool?: Pool;
+}
+export interface ItemMetadata {
+    /** Item ID. Should always be available, unless it's impossible (for example, when failing to create an item). */
+    id?: string | null;
+    /** Index of the item within the request array. Allows for correlation between request and response items. */
+    originalIndex?: number;
+    /** Whether the requested action was successful for this item. When `false`, the `error` field is populated. */
+    success?: boolean;
+    /** Details about the error in case of failure. */
+    error?: ApplicationError;
+}
+export interface ApplicationError {
+    /** Error code. */
+    code?: string;
+    /** Description of the error. */
+    description?: string;
+    /** Data related to the error. */
+    data?: Record<string, any> | null;
+}
+export interface BulkActionMetadata {
+    /** Number of items that were successfully processed. */
+    totalSuccesses?: number;
+    /** Number of items that couldn't be processed. */
+    totalFailures?: number;
+    /** Number of failures without details because detailed failure threshold was exceeded. */
+    undetailedFailures?: number;
+}
+export interface ProvisionPoolsForProgramRequest {
+    /** Reference of the template that is used to provision the pools */
+    poolDefinitionLookupId?: PoolDefinitionLookupId;
+    /** Program that the provisioned pools are part of */
+    programId?: string;
+}
+export interface PoolDefinitionLookupId extends PoolDefinitionLookupIdIdOneOf {
+    /** Pool definition ID. */
+    poolDefinitionId?: string;
+    /** Program definition ID. */
+    programDefinitionId?: string;
+}
+/** @oneof */
+export interface PoolDefinitionLookupIdIdOneOf {
+    /** Pool definition ID. */
+    poolDefinitionId?: string;
+    /** Program definition ID. */
+    programDefinitionId?: string;
+}
+export interface ProvisionPoolsForProgramResponse extends ProvisionPoolsForProgramResponseResultOneOf {
+    /** Sync result */
+    syncOptions?: SyncResult;
+    /** Async result */
+    asyncOptions?: AsyncResult;
+    /** Job ID of the program provision associated with this pool. */
+    jobId?: string;
+    /** Type of the result */
+    type?: ProvisionPoolsForProgramResponseType;
+}
+/** @oneof */
+export interface ProvisionPoolsForProgramResponseResultOneOf {
+    /** Sync result */
+    syncOptions?: SyncResult;
+    /** Async result */
+    asyncOptions?: AsyncResult;
+}
+export declare enum ProvisionPoolsForProgramResponseType {
+    /** Unknown result type */
+    UNKNOWN = "UNKNOWN",
+    /** Sync result */
+    SYNC = "SYNC",
+    /** Async result */
+    ASYNC = "ASYNC"
+}
+export interface SyncResult {
+    /** Indicates if the operation was successful */
+    success?: boolean;
+}
+export interface AsyncResult {
+    /** Job ID of the program provision associated with this pool. */
+    jobId?: string;
+}
+export interface InvalidPoolDefinitionReference {
+    /** Reference of the template that didn't find any pool definitions */
+    poolDefinitionLookupId?: PoolDefinitionLookupId;
+}
+export interface RenewPoolsForProgramRequest {
+    /** Package of pools to grant. Package id should be the same that was used to provision programs. */
+    programId?: string;
+}
+export interface RenewPoolsForProgramResponse {
+    /** Job id of the renewal job */
+    jobId?: string;
+}
+export interface UpdatePoolStatusRequest extends UpdatePoolStatusRequestPoolSelectorOneOf {
+    /** Pool selector by pool definition id and program definition id */
+    byPoolDefinitionIdAndProgramDefinitionIdOptions?: ByPoolDefinitionIdAndProgramDefinitionIdOptions;
+    /** Pool selector by program id */
+    byProgramIdOptions?: ByProgramIdOptions;
+    /** New pool status */
+    status?: PoolStatus;
+    /** Pool selector type */
+    poolSelectorType?: PoolSelectorType;
+}
+/** @oneof */
+export interface UpdatePoolStatusRequestPoolSelectorOneOf {
+    /** Pool selector by pool definition id and program definition id */
+    byPoolDefinitionIdAndProgramDefinitionIdOptions?: ByPoolDefinitionIdAndProgramDefinitionIdOptions;
+    /** Pool selector by program id */
+    byProgramIdOptions?: ByProgramIdOptions;
+}
+export declare enum PoolSelectorType {
+    UNKNOWN_SELECTOR = "UNKNOWN_SELECTOR",
+    BY_POOL_DEFINITION_ID_AND_PROGRAM_DEFINITION_ID = "BY_POOL_DEFINITION_ID_AND_PROGRAM_DEFINITION_ID",
+    BY_PROGRAM_ID = "BY_PROGRAM_ID"
+}
+export interface ByPoolDefinitionIdAndProgramDefinitionIdOptions {
+    /** Pool definition id */
+    poolDefinitionId?: string;
+    /** Program definition id */
+    programDefinitionId?: string | null;
+}
+export interface ByProgramIdOptions {
+    /** Program id */
+    programId?: string;
+    /** Additional data that gets added to the event once the async job completes */
+    additionalData?: Record<string, any> | null;
+}
+export interface UpdatePoolStatusResponse {
+    /** Job ID of the program provision associated with this pool. */
+    jobId?: string;
+}
+export interface CountNumberOfPoolsInProvisioningStatusRequest {
+    /** Program id */
+    programId?: string;
+}
+export interface CountNumberOfPoolsInProvisioningStatusResponse {
+    /** Number of pools in provisioning status */
+    count?: number;
+}
+export interface DomainEvent extends DomainEventBodyOneOf {
+    createdEvent?: EntityCreatedEvent;
+    updatedEvent?: EntityUpdatedEvent;
+    deletedEvent?: EntityDeletedEvent;
+    actionEvent?: ActionEvent;
+    /**
+     * Unique event ID.
+     * Allows clients to ignore duplicate webhooks.
+     */
+    id?: string;
+    /**
+     * Assumes actions are also always typed to an entity_type
+     * Example: wix.stores.catalog.product, wix.bookings.session, wix.payments.transaction
+     */
+    entityFqdn?: string;
+    /**
+     * This is top level to ease client code dispatching of messages (switch on entity_fqdn+slug)
+     * This is although the created/updated/deleted notion is duplication of the oneof types
+     * Example: created/updated/deleted/started/completed/email_opened
+     */
+    slug?: string;
+    /** ID of the entity associated with the event. */
+    entityId?: string;
+    /** Event timestamp in [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) format and UTC time. For example: 2020-04-26T13:57:50.699Z */
+    eventTime?: Date | null;
+    /**
+     * Whether the event was triggered as a result of a privacy regulation application
+     * (for example, GDPR).
+     */
+    triggeredByAnonymizeRequest?: boolean | null;
+    /** If present, indicates the action that triggered the event. */
+    originatedFrom?: string | null;
+    /**
+     * A sequence number defining the order of updates to the underlying entity.
+     * For example, given that some entity was updated at 16:00 and than again at 16:01,
+     * it is guaranteed that the sequence number of the second update is strictly higher than the first.
+     * As the consumer, you can use this value to ensure that you handle messages in the correct order.
+     * To do so, you will need to persist this number on your end, and compare the sequence number from the
+     * message against the one you have stored. Given that the stored number is higher, you should ignore the message.
+     */
+    entityEventSequence?: string | null;
+}
+/** @oneof */
+export interface DomainEventBodyOneOf {
+    createdEvent?: EntityCreatedEvent;
+    updatedEvent?: EntityUpdatedEvent;
+    deletedEvent?: EntityDeletedEvent;
+    actionEvent?: ActionEvent;
+}
+export interface EntityCreatedEvent {
+    entityAsJson?: string;
+    /** Indicates the event was triggered by a restore-from-trashbin operation for a previously deleted entity */
+    restoreInfo?: RestoreInfo;
+}
+export interface RestoreInfo {
+    deletedDate?: Date | null;
+}
+export interface EntityUpdatedEvent {
+    /**
+     * Since platformized APIs only expose PATCH and not PUT we can't assume that the fields sent from the client are the actual diff.
+     * This means that to generate a list of changed fields (as opposed to sent fields) one needs to traverse both objects.
+     * We don't want to impose this on all developers and so we leave this traversal to the notification recipients which need it.
+     */
+    currentEntityAsJson?: string;
+}
+export interface EntityDeletedEvent {
+    /** Entity that was deleted */
+    deletedEntityAsJson?: string | null;
+}
+export interface ActionEvent {
+    bodyAsJson?: string;
+}
+export interface MessageEnvelope {
+    /** App instance ID. */
+    instanceId?: string | null;
+    /** Event type. */
+    eventType?: string;
+    /** The identification type and identity data. */
+    identity?: IdentificationData;
+    /** Stringify payload. */
+    data?: string;
+}
+export interface IdentificationData extends IdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+    /** ID of an app. */
+    appId?: string;
+    /** @readonly */
+    identityType?: WebhookIdentityType;
+}
+/** @oneof */
+export interface IdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+    /** ID of an app. */
+    appId?: string;
+}
+export declare enum WebhookIdentityType {
+    UNKNOWN = "UNKNOWN",
+    ANONYMOUS_VISITOR = "ANONYMOUS_VISITOR",
+    MEMBER = "MEMBER",
+    WIX_USER = "WIX_USER",
+    APP = "APP"
+}
+interface CommonIdentificationDataNonNullableFields {
+    anonymousVisitorId: string;
+    memberId: string;
+    wixUserId: string;
+    identityType: IdentityType;
+}
+interface PolicyExpressionNotNonNullableFields {
+    expression?: PolicyExpressionNonNullableFields;
+}
+interface PolicyExpressionAndNonNullableFields {
+    expressions: PolicyExpressionNonNullableFields[];
+}
+interface PolicyExpressionOrNonNullableFields {
+    expressions: PolicyExpressionNonNullableFields[];
+}
+interface FixedIntervalPolicyNonNullableFields {
+    fromWeekDay: WeekDay;
+    toWeekDay: WeekDay;
+}
+interface RateLimitedPolicyNonNullableFields {
+    fixedIntervalOptions?: FixedIntervalPolicyNonNullableFields;
+    times: number;
+    type: RateLimitedPolicyType;
+}
+interface CustomPolicyNonNullableFields {
+    id: string;
+}
+interface PolicyNonNullableFields {
+    fixedIntervalOptions?: FixedIntervalPolicyNonNullableFields;
+    rateLimitedOptions?: RateLimitedPolicyNonNullableFields;
+    customOptions?: CustomPolicyNonNullableFields;
+    type: Type;
+}
+interface PolicyExpressionNonNullableFields {
+    operatorNotOptions?: PolicyExpressionNotNonNullableFields;
+    operatorAndOptions?: PolicyExpressionAndNonNullableFields;
+    operatorOrOptions?: PolicyExpressionOrNonNullableFields;
+    policyOptions?: PolicyNonNullableFields;
+    type: PolicyExpressionType;
+}
+interface BenefitNonNullableFields {
+    benefitKey: string;
+    policyExpression?: PolicyExpressionNonNullableFields;
+}
+interface CreditConfigurationNonNullableFields {
+    amount: string;
+}
+interface DetailsNonNullableFields {
+    benefits: BenefitNonNullableFields[];
+    creditConfiguration?: CreditConfigurationNonNullableFields;
+    policyExpression?: PolicyExpressionNonNullableFields;
+}
+interface ProgramDefinitionInfoNonNullableFields {
+    id: string;
+}
+interface ProgramInfoNonNullableFields {
+    id: string;
+}
+interface PoolNonNullableFields {
+    status: PoolStatus;
+    beneficiary?: CommonIdentificationDataNonNullableFields;
+    details?: DetailsNonNullableFields;
+    displayName: string;
+    programDefinition?: ProgramDefinitionInfoNonNullableFields;
+    program?: ProgramInfoNonNullableFields;
+    previousStatus: PoolStatus;
+    origin: PoolOrigin;
+}
+export interface GetPoolResponseNonNullableFields {
+    pool?: PoolNonNullableFields;
+}
+export interface UpdatePoolResponseNonNullableFields {
+    pool?: PoolNonNullableFields;
+}
+export interface QueryPoolsResponseNonNullableFields {
+    pools: PoolNonNullableFields[];
+}
+export interface RedeemBenefitResponseNonNullableFields {
+    transactionId: string;
+}
+interface ItemReferenceNonNullableFields {
+    externalId: string;
+    category: string;
+    providerAppId: string;
+}
+interface EligibleBenefitNonNullableFields {
+    poolId: string;
+    benefitKey: string;
+    itemReference?: ItemReferenceNonNullableFields;
+}
+interface EligibleNonNullableFields {
+    eligibleBenefits: EligibleBenefitNonNullableFields[];
+}
+interface NotEnoughBalanceNonNullableFields {
+    poolId: string;
+    itemReference?: ItemReferenceNonNullableFields;
+    availableBalance: string;
+    requestedBalance: string;
+}
+interface FailureDetailsNonNullableFields {
+    code: string;
+}
+interface PolicyExpressionEvaluatedToFalseNonNullableFields {
+    poolId: string;
+    itemReference?: ItemReferenceNonNullableFields;
+    failureDetails: FailureDetailsNonNullableFields[];
+}
+interface PoolNotActiveNonNullableFields {
+    poolId: string;
+    poolStatus: PoolStatus;
+}
+interface BenefitNotFoundNonNullableFields {
+    poolId: string;
+}
+interface PoolNotFoundNonNullableFields {
+    poolId: string;
+}
+interface EligibilityCheckResultNonNullableFields {
+    eligibleOptions?: EligibleNonNullableFields;
+    notEnoughBalanceOptions?: NotEnoughBalanceNonNullableFields;
+    policyExpressionEvaluatedToFalseOptions?: PolicyExpressionEvaluatedToFalseNonNullableFields;
+    poolNotActiveOptions?: PoolNotActiveNonNullableFields;
+    benefitNotFoundOptions?: BenefitNotFoundNonNullableFields;
+    poolNotFoundOptions?: PoolNotFoundNonNullableFields;
+    type: EligibilityCheckResultType;
+}
+export interface CheckBenefitEligibilityResponseNonNullableFields {
+    result?: EligibilityCheckResultNonNullableFields;
+}
+interface BenefitSelectorNonNullableFields {
+    poolId: string;
+    itemReference?: ItemReferenceNonNullableFields;
+    count: number;
+}
+interface BulkEligibilityCheckResultNonNullableFields {
+    benefitSelector?: BenefitSelectorNonNullableFields;
+    result?: EligibilityCheckResultNonNullableFields;
+}
+export interface BulkCheckBenefitEligibilityResponseNonNullableFields {
+    results: BulkEligibilityCheckResultNonNullableFields[];
+}
+export interface GetEligibleBenefitsResponseNonNullableFields {
+    eligibleBenefits: EligibleBenefitNonNullableFields[];
+}
+interface ApplicationErrorNonNullableFields {
+    code: string;
+    description: string;
+}
+interface ItemMetadataNonNullableFields {
+    originalIndex: number;
+    success: boolean;
+    error?: ApplicationErrorNonNullableFields;
+}
+interface BulkPoolResultNonNullableFields {
+    poolMetadata?: ItemMetadataNonNullableFields;
+    pool?: PoolNonNullableFields;
+}
+interface BulkActionMetadataNonNullableFields {
+    totalSuccesses: number;
+    totalFailures: number;
+    undetailedFailures: number;
+}
+export interface BulkUpdatePoolsResponseNonNullableFields {
+    results: BulkPoolResultNonNullableFields[];
+    bulkActionMetadata?: BulkActionMetadataNonNullableFields;
+}
+export {};