import type { AppleSubscriptionStatusRequest } from '../models/AppleSubscriptionStatusRequest';
import type { AppleSubscriptionStatusView } from '../models/AppleSubscriptionStatusView';
import type { AppleVerifyTransactionId } from '../models/AppleVerifyTransactionId';
import type { AssociateAccountResponse } from '../models/AssociateAccountResponse';
import type { AssociateAppleAccount } from '../models/AssociateAppleAccount';
import type { AWSTenantLaunchRequest } from '../models/AWSTenantLaunchRequest';
import type { BaseResponse } from '../models/BaseResponse';
import type { GCPTenantLaunchRequest } from '../models/GCPTenantLaunchRequest';
import type { GooglePayAccountResponse } from '../models/GooglePayAccountResponse';
import type { GooglePayVerifyToken } from '../models/GooglePayVerifyToken';
import type { StripeCheckoutSessionRequest } from '../models/StripeCheckoutSessionRequest';
import type { StripeCheckoutSessionResponse } from '../models/StripeCheckoutSessionResponse';
import type { StripeConnectDashboardLink } from '../models/StripeConnectDashboardLink';
import type { StripeConnectOnboard } from '../models/StripeConnectOnboard';
import type { StripeConnectOnboardResponse } from '../models/StripeConnectOnboardResponse';
import type { StripeConnectStatus } from '../models/StripeConnectStatus';
import type { StripeContext } from '../models/StripeContext';
import type { StripeCustomerPortalRequest } from '../models/StripeCustomerPortalRequest';
import type { StripeCustomerPortalResponse } from '../models/StripeCustomerPortalResponse';
import type { StripeLocalProduct } from '../models/StripeLocalProduct';
import type { StripeNewUserTenantLaunchRequest } from '../models/StripeNewUserTenantLaunchRequest';
import type { StripePricingPageSessionResponse } from '../models/StripePricingPageSessionResponse';
import type { StripeSubscriptionRenewalRequest } from '../models/StripeSubscriptionRenewalRequest';
import type { StripeSubscriptionRenewalResponse } from '../models/StripeSubscriptionRenewalResponse';
import type { TenantLaunchRequest } from '../models/TenantLaunchRequest';
import type { TenantLaunchResponse } from '../models/TenantLaunchResponse';
import type { VerifyGCPMarketPlaceRequest } from '../models/VerifyGCPMarketPlaceRequest';
import type { VerifyGCPMarketPlaceResponse } from '../models/VerifyGCPMarketPlaceResponse';
import type { CancelablePromise } from '../core/CancelablePromise';
export declare class CommerceService {
    /**
     * Handle callbacks from Stripe after successful checkout.
     *
     * Updates:
     * - Platform launch state
     * - Association configuration status
     * @returns any
     * @throws ApiError
     */
    static providerAssociationStripeCallbackRetrieve({ launchId, }: {
        launchId: string;
    }): CancelablePromise<{
        message?: string;
    }>;
    /**
     * Associate an Apple account with a user known user
     * @returns AssociateAccountResponse
     * @throws ApiError
     */
    static providersAppleAssociateAccountCreate({ requestBody, }: {
        requestBody: AssociateAppleAccount;
    }): CancelablePromise<AssociateAccountResponse>;
    /**
     * View to handle apple webhooks
     * @returns any No response body
     * @throws ApiError
     */
    static providersAppleHookCreate(): CancelablePromise<any>;
    /**
     * Returns information about a user subscription status
     * @returns AppleSubscriptionStatusView
     * @throws ApiError
     */
    static providersAppleSubscriptionStatusCreate({ requestBody, }: {
        requestBody?: AppleSubscriptionStatusRequest;
    }): CancelablePromise<AppleSubscriptionStatusView>;
    /**
     * Checks if a provided transaction_id is valid
     * @returns BaseResponse
     * @throws ApiError
     */
    static providersAppleValidateTransactionIdCreate({ requestBody, }: {
        requestBody: AppleVerifyTransactionId;
    }): CancelablePromise<BaseResponse>;
    /**
     * Serves a view that redirects to the AWS marketplace create organization page
     *
     * Set CREATE_ORGANIZATION_URL in GlobalConfigurationFetcher to the
     * URL of the AWS marketplace create organization page
     * @returns any No response body
     * @throws ApiError
     */
    static providersAwsCreateOrganizationCreate(): CancelablePromise<any>;
    /**
     * API endpoint to get domain setup status
     * @returns any No response body
     * @throws ApiError
     */
    static providersAwsDomainStatusRetrieve(): CancelablePromise<any>;
    /**
     * Proxy to the Platform launch API
     *
     * We cannot expose launching a tenant to an authorized user hence the need for the API
     *
     * The API validates the x_amzn_marketplace_token and then proxies the request to the Platform Launch API
     * @returns TenantLaunchResponse
     * @throws ApiError
     */
    static providersAwsLaunchTenantCreate({ requestBody, }: {
        requestBody: AWSTenantLaunchRequest;
    }): CancelablePromise<TenantLaunchResponse>;
    /**
     * API endpoint to get/update CNAME records for domain setup
     * @returns any No response body
     * @throws ApiError
     */
    static providersAwsSyncDomainRecordsRetrieve(): CancelablePromise<any>;
    /**
     * API endpoint to get/update CNAME records for domain setup
     * @returns any No response body
     * @throws ApiError
     */
    static providersAwsSyncDomainRecordsCreate(): CancelablePromise<any>;
    /**
     * Serves a view that redirects to the GCP marketplace create organization page
     *
     * Set CREATE_ORGANIZATION_URL in GlobalConfigurationFetcher to the URL of the GCP marketplace create organization
     * page
     * @returns any No response body
     * @throws ApiError
     */
    static providersGcpCreateOrganizationCreate(): CancelablePromise<any>;
    /**
     * Serves a view that redirects to the GCP marketplace create organization page
     *
     * Set CREATE_ORGANIZATION_URL in GlobalConfigurationFetcher to the URL of the GCP marketplace create organization
     * page
     * @returns any No response body
     * @throws ApiError
     */
    static providersGcpCreateOrganizationCreate2({ productId, }: {
        productId: string;
    }): CancelablePromise<any>;
    /**
     * @returns any No response body
     * @throws ApiError
     */
    static providersGcpHookCreate(): CancelablePromise<any>;
    /**
     * Proxy to the Platform launch API
     *
     * We cannot expose launching a tenant to an authorized user hence the need for the API
     *
     * The API validates the x_gcp_marketplace_token and then proxies the request to the Platform Launc API
     * @returns TenantLaunchResponse
     * @throws ApiError
     */
    static providersGcpLaunchTenantCreate({ requestBody, }: {
        requestBody: GCPTenantLaunchRequest;
    }): CancelablePromise<TenantLaunchResponse>;
    /**
     * @returns VerifyGCPMarketPlaceResponse
     * @throws ApiError
     */
    static providersGcpValidateSignupTokenCreate({ requestBody, }: {
        requestBody: VerifyGCPMarketPlaceRequest;
    }): CancelablePromise<VerifyGCPMarketPlaceResponse>;
    /**
     * Google Allows us to pass an obfuscated account id to be sent to during a subscription purchase
     * @returns GooglePayAccountResponse
     * @throws ApiError
     */
    static providersGooglePayGetAccountRetrieve({ bundleId, }: {
        bundleId: string;
    }): CancelablePromise<GooglePayAccountResponse>;
    /**
     * View to handle Google Pay webhooks
     * @returns any No response body
     * @throws ApiError
     */
    static providersGooglePayHookCreate(): CancelablePromise<any>;
    /**
     * Associate a Google Pay account with a known user
     * @returns BaseResponse
     * @throws ApiError
     */
    static providersGooglePayValidateTransactionIdCreate({ requestBody, }: {
        requestBody: GooglePayVerifyToken;
    }): CancelablePromise<BaseResponse>;
    /**
     * Proxy to the Platform launch API
     *
     * We cannot expose launching a tenant to an unauthorized user hence the need for the API
     *
     * The API validates the stripe_checkout_id and then proxies the request to the Platform Launch API
     * @returns TenantLaunchResponse
     * @throws ApiError
     */
    static providersStripeCreateOrganizationCreate({ requestBody, }: {
        requestBody: StripeNewUserTenantLaunchRequest;
    }): CancelablePromise<TenantLaunchResponse>;
    /**
     * POST
     * Update platform provisioning config
     *
     * request body:
     * {"config_name": "demo_config}
     * @returns any No response body
     * @throws ApiError
     */
    static provisionCreate({ configName, }: {
        configName: string;
    }): CancelablePromise<any>;
    /**
     * User/tenant creation API
     *
     * To create using any payment provider, ensure you use the StudentToken Authentication Mechanism
     * and also include the correct `provider_key` in the request body:
     *
     * ```
     * apple_transaction_id: str
     * stripe_checkout_id: str
     * x_gcp_marketplace_token: str
     * aws_transaction_id: str
     * google_pay_transaction_id: str
     * ```
     *
     * To create a tenant without a payment provider, call the API without ny of the above provider keys in the request body
     * @returns TenantLaunchResponse
     * @throws ApiError
     */
    static serviceLaunchTenantCreate({ requestBody, }: {
        requestBody: TenantLaunchRequest;
    }): CancelablePromise<TenantLaunchResponse>;
    /**
     * User creation flow
     * @returns any No response body
     * @throws ApiError
     */
    static serviceManageUserCreate(): CancelablePromise<any>;
    /**
     * Make user tenant admin
     * @returns any No response body
     * @throws ApiError
     */
    static serviceManageUserRoleCreate(): CancelablePromise<any>;
    /**
     * Stripe checkout session API View for user upgrade
     *
     * Request the following fields:
     *
     * - tenant
     * - sku
     * - mode
     * - success_url
     * - cancel_url
     *
     * Response:
     * {
         * "redirect_to": "https://checkout.stripe.com/xxx/xxxx/xxxx",
         * }
         * @returns StripeCheckoutSessionResponse
         * @throws ApiError
         */
    static serviceOrgsUsersStripeCheckoutSessionCreate({ org, userId, requestBody, }: {
        org: string;
        requestBody: StripeCheckoutSessionRequest;
    }): CancelablePromise<StripeCheckoutSessionResponse>;
    /**
     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
     * @returns StripeCustomerPortalResponse
     * @throws ApiError
     */
    static serviceOrgsUsersStripeCustomerPortalCreate({ org, userId, requestBody, }: {
        org: string;
        requestBody: StripeCustomerPortalRequest;
    }): CancelablePromise<StripeCustomerPortalResponse>;
    /**
     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
     * @returns StripeLocalProduct
     * @throws ApiError
     */
    static serviceOrgsUsersStripeProductsRetrieve({ org, userId, }: {
        org: string;
    }): CancelablePromise<StripeLocalProduct>;
    /**
     * Mixin that includes the StudentTokenAuthentication and IsPlatformAdmin
     * @returns any No response body
     * @throws ApiError
     */
    static serviceOrgsUsersStripeProductsManageCreate({ org, userId, }: {
        org: string;
    }): CancelablePromise<any>;
    /**
     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
     * @returns StripeSubscriptionRenewalResponse
     * @throws ApiError
     */
    static serviceOrgsUsersStripeSubscriptionRenewalCreate({ org, userId, requestBody, }: {
        org: string;
        requestBody: StripeSubscriptionRenewalRequest;
    }): CancelablePromise<StripeSubscriptionRenewalResponse>;
    /**
     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
     * @returns any No response body
     * @throws ApiError
     */
    static serviceOrgsUsersStripeSubscriptionsRetrieve({ org, userId, }: {
        org: string;
    }): CancelablePromise<any>;
    /**
     * Handle course payment callback after successful Stripe checkout.
     * Enrolls the user in the purchased course.
     *
     * URL Parameters:
     * - stripe_checkout_id: The local Checkout Session UUID
     *
     * Response:
     * - Redirect: Successfully processed course enrollment
     * - 404: Checkout session not found
     * - 400: Invalid checkout session or product
     * - 500: Server error during processing
     * @returns any No response body
     * @throws ApiError
     */
    static serviceOrgsStripeCoursePaymentCallbackRetrieve({ platformKey, }: {
        platformKey: string;
    }): CancelablePromise<any>;
    /**
     * Disconnect Stripe Connect account
     * @returns any
     * @throws ApiError
     */
    static servicePlatformsStripeConnectDestroy({ platformKey, }: {
        platformKey: string;
    }): CancelablePromise<Record<string, any>>;
    /**
     * Get Express Dashboard login link
     * @returns StripeConnectDashboardLink
     * @throws ApiError
     */
    static servicePlatformsStripeConnectDashboardRetrieve({ platformKey, }: {
        platformKey: string;
    }): CancelablePromise<StripeConnectDashboardLink>;
    /**
     * Start Stripe Connect onboarding for platform admin
     * @returns StripeConnectOnboardResponse
     * @throws ApiError
     */
    static servicePlatformsStripeConnectOnboardCreate({ platformKey, requestBody, }: {
        platformKey: string;
        requestBody: StripeConnectOnboard;
    }): CancelablePromise<StripeConnectOnboardResponse>;
    /**
     * Start Stripe Connect onboarding for platform admin
     * @returns StripeConnectOnboardResponse
     * @throws ApiError
     */
    static servicePlatformsStripeConnectOnboardRefreshCreate({ platformKey, requestBody, }: {
        platformKey: string;
        requestBody: StripeConnectOnboard;
    }): CancelablePromise<StripeConnectOnboardResponse>;
    /**
     * Get Connect account status
     * @returns StripeConnectStatus
     * @throws ApiError
     */
    static servicePlatformsStripeConnectStatusRetrieve({ platformKey, }: {
        platformKey: string;
    }): CancelablePromise<StripeConnectStatus>;
    /**
     * Create a uuid to help us track internally user initiated checkout
     * @returns StripeContext
     * @throws ApiError
     */
    static servicePlatformsStripeContextRetrieve({ platformKey, }: {
        platformKey: string;
    }): CancelablePromise<StripeContext>;
    /**
     * Unified callback after successful Stripe checkout.
     *
     * Handles both subscription (pricing page) and credit-topup (payment mode)
     * checkouts. The checkout type is determined from the Stripe session automatically.
     *
     * URL Parameters:
     * - checkout_session_id: The Stripe Checkout Session ID (optional in URL,
     * can also be passed as ?stripe_checkout_id query param)
     *
     * Response:
     * - Redirect: Successfully validated and sending to next page
     * - 404: Checkout session not found
     * - 400: Invalid checkout session or product
     * @returns any No response body
     * @throws ApiError
     */
    static servicePlatformsStripeCreditTopupCallbackRetrieve({ checkoutSessionId, platformKey, }: {
        checkoutSessionId: string;
        platformKey: string;
    }): CancelablePromise<any>;
    /**
     * Unified callback after successful Stripe checkout.
     *
     * Handles both subscription (pricing page) and credit-topup (payment mode)
     * checkouts. The checkout type is determined from the Stripe session automatically.
     *
     * URL Parameters:
     * - checkout_session_id: The Stripe Checkout Session ID (optional in URL,
     * can also be passed as ?stripe_checkout_id query param)
     *
     * Response:
     * - Redirect: Successfully validated and sending to next page
     * - 404: Checkout session not found
     * - 400: Invalid checkout session or product
     * @returns any No response body
     * @throws ApiError
     */
    static servicePlatformsStripePricingPageCallbackRetrieve({ platformKey, }: {
        platformKey: string;
    }): CancelablePromise<any>;
    /**
     * Unified callback after successful Stripe checkout.
     *
     * Handles both subscription (pricing page) and credit-topup (payment mode)
     * checkouts. The checkout type is determined from the Stripe session automatically.
     *
     * URL Parameters:
     * - checkout_session_id: The Stripe Checkout Session ID (optional in URL,
     * can also be passed as ?stripe_checkout_id query param)
     *
     * Response:
     * - Redirect: Successfully validated and sending to next page
     * - 404: Checkout session not found
     * - 400: Invalid checkout session or product
     * @returns any No response body
     * @throws ApiError
     */
    static servicePlatformsStripePricingPageCallbackRetrieve2({ checkoutSessionId, platformKey, }: {
        checkoutSessionId: string;
        platformKey: string;
    }): CancelablePromise<any>;
    /**
     * Create a uuid to track user-initiated pricing page checkouts.
     *
     * Works for both authenticated and unauthenticated (guest) users.
     * Accepts optional `redirect_url` and `source_platform_key` query params.
     * @returns StripePricingPageSessionResponse
     * @throws ApiError
     */
    static servicePlatformsStripePricingPageSessionRetrieve({ platformKey, }: {
        platformKey: string;
    }): CancelablePromise<StripePricingPageSessionResponse>;
    /**
     * @returns any No response body
     * @throws ApiError
     */
    static serviceStripeCheckoutRetrieve({ checkoutUuid, }: {
        checkoutUuid: string;
    }): CancelablePromise<any>;
    /**
     * Stripe free trial checkout session. No user auth
     *
     * Request the following fields:
     *
     * - success_url
     * - cancel_url
     * - product
     *
     * Response:
     * {
         * "redirect_to": "https://checkout.stripe.com/xxx/xxxx/xxxx",
         * }
         * @returns StripeCheckoutSessionResponse
         * @throws ApiError
         */
    static serviceStripeCheckoutFreeTrialCreate({ requestBody, }: {
        requestBody: StripeCheckoutSessionResponse;
    }): CancelablePromise<StripeCheckoutSessionResponse>;
    /**
     * Public GET endpoint that creates a Stripe checkout session and redirects to Stripe.
     * After checkout, routes through pricing-page-callback for tenant provisioning.
     *
     * URL: /api/service/stripe/checkout/redirect/<sku>/
     * Query params:
     * - redirect_url (optional): Final destination after successful checkout + provisioning.
     * When omitted, the pricing-page-callback uses its default redirect.
     * - cancel_url (optional): Where to redirect if checkout is cancelled.
     * Defaults to the mentor AI portal.
     * @returns any No response body
     * @throws ApiError
     */
    static serviceStripeCheckoutRedirectRetrieve({ sku, }: {
        sku: string;
    }): CancelablePromise<any>;
    /**
     * Stripe checkout session API View for new users (first-time subscription)
     *
     * Request the following fields:
     *
     * - user_id, username, or email (user identifier)
     * - tenant (tenant type to create after successful checkout)
     * - sku
     * - mode (choices: "subscription", "payment", "setup")
     * - success_url
     * - cancel_url
     * - period (optional): Billing period - "weekly", "monthly", or "yearly" (defaults to "monthly")
     * - skip_card (optional): Skip card collection for free plans
     * - is_free_trial (optional): Enable free trial mode
     *
     * Response:
     * {
         * "redirect_to": "https://checkout.stripe.com/xxx/xxxx/xxxx",
         * }
         * @returns StripeCheckoutSessionResponse
         * @throws ApiError
         */
    static serviceStripeNewUserCheckoutCreate({ requestBody, }: {
        requestBody: StripeCheckoutSessionRequest;
    }): CancelablePromise<StripeCheckoutSessionResponse>;
    /**
     * Check if a tenant with a given key, org, or name exists.
     *
     * At least one non-empty filter parameter (key, org, or name) is required.
     * @returns any No response body
     * @throws ApiError
     */
    static serviceTenantValidationCreate(): CancelablePromise<any>;
    /**
     * GET
     * Gets site hash_key from
     * or
     * Gets site_id form hash_key
     * @returns any No response body
     * @throws ApiError
     */
    static serviceTokenRetrieve(): CancelablePromise<any>;
    /**
     * Check if tenant exists or not
     * @returns any No response body
     * @throws ApiError
     */
    static serviceUserValidationCreate(): CancelablePromise<any>;
}