/**
 * Azure Marketplace API
 *
 * Generated from the Azure REST API specs.
 * DO NOT EDIT - regenerate with: bun run generate
 */
import * as Schema from "effect/Schema";
export declare const OperationsListInput: Schema.Struct<{
    readonly "api-version": Schema.String;
}>;
export type OperationsListInput = typeof OperationsListInput.Type;
export declare const OperationsListOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly isDataAction: Schema.optional<Schema.Boolean>;
        readonly display: Schema.optional<Schema.Struct<{
            readonly provider: Schema.optional<Schema.String>;
            readonly resource: Schema.optional<Schema.String>;
            readonly operation: Schema.optional<Schema.String>;
            readonly description: Schema.optional<Schema.String>;
        }>>;
        readonly origin: Schema.optional<Schema.String>;
        readonly properties: Schema.optional<Schema.Unknown>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type OperationsListOutput = typeof OperationsListOutput.Type;
/**
 * Lists all of the available Microsoft.Marketplace REST API operations.
 *
 * @param api-version - The API version to use for this operation.
 */
export declare const OperationsList: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly display?: {
            readonly description?: string | undefined;
            readonly operation?: string | undefined;
            readonly provider?: string | undefined;
            readonly resource?: string | undefined;
        } | undefined;
        readonly id?: string | undefined;
        readonly isDataAction?: boolean | undefined;
        readonly name?: string | undefined;
        readonly origin?: string | undefined;
        readonly properties?: unknown;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreAcknowledgeOfferNotificationInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly offerId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreAcknowledgeOfferNotificationInput = typeof PrivateStoreAcknowledgeOfferNotificationInput.Type;
export declare const PrivateStoreAcknowledgeOfferNotificationOutput: Schema.Void;
export type PrivateStoreAcknowledgeOfferNotificationOutput = typeof PrivateStoreAcknowledgeOfferNotificationOutput.Type;
/**
 * Acknowledge notification for offer
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param offerId - The offer ID to update or delete
 */
export declare const PrivateStoreAcknowledgeOfferNotification: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly offerId: string;
    readonly privateStoreId: string;
}, void, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreAdminRequestApprovalsListInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreAdminRequestApprovalsListInput = typeof PrivateStoreAdminRequestApprovalsListInput.Type;
export declare const PrivateStoreAdminRequestApprovalsListOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
        readonly systemData: Schema.optional<Schema.Struct<{
            readonly createdBy: Schema.optional<Schema.String>;
            readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly createdAt: Schema.optional<Schema.String>;
            readonly lastModifiedBy: Schema.optional<Schema.String>;
            readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly lastModifiedAt: Schema.optional<Schema.String>;
        }>>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type PrivateStoreAdminRequestApprovalsListOutput = typeof PrivateStoreAdminRequestApprovalsListOutput.Type;
/**
 * Get list of admin request approvals
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreAdminRequestApprovalsList: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly systemData?: {
            readonly createdAt?: string | undefined;
            readonly createdBy?: string | undefined;
            readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
            readonly lastModifiedAt?: string | undefined;
            readonly lastModifiedBy?: string | undefined;
            readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        } | undefined;
        readonly type?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreAnyExistingOffersInTheCollectionsInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreAnyExistingOffersInTheCollectionsInput = typeof PrivateStoreAnyExistingOffersInTheCollectionsInput.Type;
export declare const PrivateStoreAnyExistingOffersInTheCollectionsOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.Boolean>;
}>;
export type PrivateStoreAnyExistingOffersInTheCollectionsOutput = typeof PrivateStoreAnyExistingOffersInTheCollectionsOutput.Type;
/**
 * Query whether exists any offer in the collections.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreAnyExistingOffersInTheCollections: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly value?: boolean | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreBillingAccountsInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreBillingAccountsInput = typeof PrivateStoreBillingAccountsInput.Type;
export declare const PrivateStoreBillingAccountsOutput: Schema.Struct<{
    readonly billingAccounts: Schema.optional<Schema.$Array<Schema.String>>;
}>;
export type PrivateStoreBillingAccountsOutput = typeof PrivateStoreBillingAccountsOutput.Type;
/**
 * Tenant billing accounts names
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreBillingAccounts: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly billingAccounts?: readonly string[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreBulkCollectionsActionInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreBulkCollectionsActionInput = typeof PrivateStoreBulkCollectionsActionInput.Type;
export declare const PrivateStoreBulkCollectionsActionOutput: Schema.Struct<{
    readonly succeeded: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly collectionName: Schema.optional<Schema.String>;
        readonly collectionId: Schema.optional<Schema.String>;
    }>>>;
    readonly failed: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly collectionName: Schema.optional<Schema.String>;
        readonly collectionId: Schema.optional<Schema.String>;
    }>>>;
}>;
export type PrivateStoreBulkCollectionsActionOutput = typeof PrivateStoreBulkCollectionsActionOutput.Type;
/**
 * Perform an action on bulk collections
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreBulkCollectionsAction: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly failed?: readonly {
        readonly collectionId?: string | undefined;
        readonly collectionName?: string | undefined;
    }[] | undefined;
    readonly succeeded?: readonly {
        readonly collectionId?: string | undefined;
        readonly collectionName?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionApproveAllItemsInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionApproveAllItemsInput = typeof PrivateStoreCollectionApproveAllItemsInput.Type;
export declare const PrivateStoreCollectionApproveAllItemsOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreCollectionApproveAllItemsOutput = typeof PrivateStoreCollectionApproveAllItemsOutput.Type;
/**
 * Delete all existing offers from the collection and enable approve all items.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const PrivateStoreCollectionApproveAllItems: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionCreateOrUpdateInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionCreateOrUpdateInput = typeof PrivateStoreCollectionCreateOrUpdateInput.Type;
export declare const PrivateStoreCollectionCreateOrUpdateOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreCollectionCreateOrUpdateOutput = typeof PrivateStoreCollectionCreateOrUpdateOutput.Type;
/**
 * Create or update private store collection
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const PrivateStoreCollectionCreateOrUpdate: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionDeleteInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionDeleteInput = typeof PrivateStoreCollectionDeleteInput.Type;
export declare const PrivateStoreCollectionDeleteOutput: Schema.Void;
export type PrivateStoreCollectionDeleteOutput = typeof PrivateStoreCollectionDeleteOutput.Type;
/**
 * Delete a collection from the given private store.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const PrivateStoreCollectionDelete: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, void, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionDisableApproveAllItemsInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionDisableApproveAllItemsInput = typeof PrivateStoreCollectionDisableApproveAllItemsInput.Type;
export declare const PrivateStoreCollectionDisableApproveAllItemsOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreCollectionDisableApproveAllItemsOutput = typeof PrivateStoreCollectionDisableApproveAllItemsOutput.Type;
/**
 * Disable approve all items for the collection.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const PrivateStoreCollectionDisableApproveAllItems: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionGetInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionGetInput = typeof PrivateStoreCollectionGetInput.Type;
export declare const PrivateStoreCollectionGetOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreCollectionGetOutput = typeof PrivateStoreCollectionGetOutput.Type;
/**
 * Gets private store collection
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const PrivateStoreCollectionGet: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionListInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionListInput = typeof PrivateStoreCollectionListInput.Type;
export declare const PrivateStoreCollectionListOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
        readonly systemData: Schema.optional<Schema.Struct<{
            readonly createdBy: Schema.optional<Schema.String>;
            readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly createdAt: Schema.optional<Schema.String>;
            readonly lastModifiedBy: Schema.optional<Schema.String>;
            readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly lastModifiedAt: Schema.optional<Schema.String>;
        }>>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type PrivateStoreCollectionListOutput = typeof PrivateStoreCollectionListOutput.Type;
/**
 * Gets private store collections list
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreCollectionList: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly systemData?: {
            readonly createdAt?: string | undefined;
            readonly createdBy?: string | undefined;
            readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
            readonly lastModifiedAt?: string | undefined;
            readonly lastModifiedBy?: string | undefined;
            readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        } | undefined;
        readonly type?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionOfferContextsViewInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly offerId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionOfferContextsViewInput = typeof PrivateStoreCollectionOfferContextsViewInput.Type;
export declare const PrivateStoreCollectionOfferContextsViewOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreCollectionOfferContextsViewOutput = typeof PrivateStoreCollectionOfferContextsViewOutput.Type;
/**
 * Retrieve offer information with plans under required contexts restrictions.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 * @param offerId - The offer ID to update or delete
 */
export declare const PrivateStoreCollectionOfferContextsView: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly offerId: string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionOfferCreateOrUpdateInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly offerId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionOfferCreateOrUpdateInput = typeof PrivateStoreCollectionOfferCreateOrUpdateInput.Type;
export declare const PrivateStoreCollectionOfferCreateOrUpdateOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreCollectionOfferCreateOrUpdateOutput = typeof PrivateStoreCollectionOfferCreateOrUpdateOutput.Type;
/**
 * Update or add an offer to a specific collection of the private store.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 * @param offerId - The offer ID to update or delete
 */
export declare const PrivateStoreCollectionOfferCreateOrUpdate: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly offerId: string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionOfferDeleteInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly offerId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionOfferDeleteInput = typeof PrivateStoreCollectionOfferDeleteInput.Type;
export declare const PrivateStoreCollectionOfferDeleteOutput: Schema.Void;
export type PrivateStoreCollectionOfferDeleteOutput = typeof PrivateStoreCollectionOfferDeleteOutput.Type;
/**
 * Deletes an offer from the given collection of private store.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 * @param offerId - The offer ID to update or delete
 */
export declare const PrivateStoreCollectionOfferDelete: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly offerId: string;
    readonly privateStoreId: string;
}, void, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionOfferGetInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly offerId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionOfferGetInput = typeof PrivateStoreCollectionOfferGetInput.Type;
export declare const PrivateStoreCollectionOfferGetOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreCollectionOfferGetOutput = typeof PrivateStoreCollectionOfferGetOutput.Type;
/**
 * Gets information about a specific offer.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 * @param offerId - The offer ID to update or delete
 */
export declare const PrivateStoreCollectionOfferGet: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly offerId: string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionOfferListInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionOfferListInput = typeof PrivateStoreCollectionOfferListInput.Type;
export declare const PrivateStoreCollectionOfferListOutput: Schema.Struct<{
    readonly value: Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
        readonly systemData: Schema.optional<Schema.Struct<{
            readonly createdBy: Schema.optional<Schema.String>;
            readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly createdAt: Schema.optional<Schema.String>;
            readonly lastModifiedBy: Schema.optional<Schema.String>;
            readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly lastModifiedAt: Schema.optional<Schema.String>;
        }>>;
    }>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type PrivateStoreCollectionOfferListOutput = typeof PrivateStoreCollectionOfferListOutput.Type;
/**
 * Get a list of all private offers in the given private store and collection
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const PrivateStoreCollectionOfferList: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, {
    readonly nextLink?: string | undefined;
    readonly value: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly systemData?: {
            readonly createdAt?: string | undefined;
            readonly createdBy?: string | undefined;
            readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
            readonly lastModifiedAt?: string | undefined;
            readonly lastModifiedBy?: string | undefined;
            readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        } | undefined;
        readonly type?: string | undefined;
    }[];
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionOfferListByContextsInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionOfferListByContextsInput = typeof PrivateStoreCollectionOfferListByContextsInput.Type;
export declare const PrivateStoreCollectionOfferListByContextsOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly context: Schema.optional<Schema.String>;
        readonly offers: Schema.optional<Schema.Struct<{
            readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
                readonly uniqueOfferId: Schema.optional<Schema.String>;
                readonly offerDisplayName: Schema.optional<Schema.String>;
                readonly publisherDisplayName: Schema.optional<Schema.String>;
                readonly eTag: Schema.optional<Schema.String>;
                readonly privateStoreId: Schema.optional<Schema.String>;
                readonly createdAt: Schema.optional<Schema.String>;
                readonly modifiedAt: Schema.optional<Schema.String>;
                readonly specificPlanIdsLimitation: Schema.optional<Schema.$Array<Schema.String>>;
                readonly updateSuppressedDueIdempotence: Schema.optional<Schema.Boolean>;
                readonly iconFileUris: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
                readonly isStopSell: Schema.optional<Schema.Boolean>;
                readonly plans: Schema.optional<Schema.$Array<Schema.Struct<{
                    readonly skuId: Schema.optional<Schema.String>;
                    readonly planId: Schema.optional<Schema.String>;
                    readonly planDisplayName: Schema.optional<Schema.String>;
                    readonly accessibility: Schema.optional<Schema.Literals<readonly ["Unknown", "Public", "PrivateTenantOnLevel", "PrivateSubscriptionOnLevel"]>>;
                    readonly altStackReference: Schema.optional<Schema.String>;
                    readonly stackType: Schema.optional<Schema.String>;
                    readonly isStopSell: Schema.optional<Schema.Boolean>;
                }>>>;
            }>>>;
        }>>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type PrivateStoreCollectionOfferListByContextsOutput = typeof PrivateStoreCollectionOfferListByContextsOutput.Type;
/**
 * Get a list of all offers in the given collection according to the required contexts.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const PrivateStoreCollectionOfferListByContexts: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly context?: string | undefined;
        readonly offers?: {
            readonly value?: readonly {
                readonly createdAt?: string | undefined;
                readonly eTag?: string | undefined;
                readonly iconFileUris?: {
                    readonly [x: string]: string;
                } | undefined;
                readonly isStopSell?: boolean | undefined;
                readonly modifiedAt?: string | undefined;
                readonly offerDisplayName?: string | undefined;
                readonly plans?: readonly {
                    readonly accessibility?: "PrivateSubscriptionOnLevel" | "PrivateTenantOnLevel" | "Public" | "Unknown" | undefined;
                    readonly altStackReference?: string | undefined;
                    readonly isStopSell?: boolean | undefined;
                    readonly planDisplayName?: string | undefined;
                    readonly planId?: string | undefined;
                    readonly skuId?: string | undefined;
                    readonly stackType?: string | undefined;
                }[] | undefined;
                readonly privateStoreId?: string | undefined;
                readonly publisherDisplayName?: string | undefined;
                readonly specificPlanIdsLimitation?: readonly string[] | undefined;
                readonly uniqueOfferId?: string | undefined;
                readonly updateSuppressedDueIdempotence?: boolean | undefined;
            }[] | undefined;
        } | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionOfferPostInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly offerId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionOfferPostInput = typeof PrivateStoreCollectionOfferPostInput.Type;
export declare const PrivateStoreCollectionOfferPostOutput: Schema.Void;
export type PrivateStoreCollectionOfferPostOutput = typeof PrivateStoreCollectionOfferPostOutput.Type;
/**
 * Delete Private store offer. This is a workaround.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 * @param offerId - The offer ID to update or delete
 */
export declare const PrivateStoreCollectionOfferPost: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly offerId: string;
    readonly privateStoreId: string;
}, void, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionOfferUpsertOfferWithMultiContextInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly offerId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionOfferUpsertOfferWithMultiContextInput = typeof PrivateStoreCollectionOfferUpsertOfferWithMultiContextInput.Type;
export declare const PrivateStoreCollectionOfferUpsertOfferWithMultiContextOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreCollectionOfferUpsertOfferWithMultiContextOutput = typeof PrivateStoreCollectionOfferUpsertOfferWithMultiContextOutput.Type;
/**
 * Upsert an offer with multiple context details.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 * @param offerId - The offer ID to update or delete
 */
export declare const PrivateStoreCollectionOfferUpsertOfferWithMultiContext: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly offerId: string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionPostInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionPostInput = typeof PrivateStoreCollectionPostInput.Type;
export declare const PrivateStoreCollectionPostOutput: Schema.Void;
export type PrivateStoreCollectionPostOutput = typeof PrivateStoreCollectionPostOutput.Type;
/**
 * Delete Private store collection. This is a workaround.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const PrivateStoreCollectionPost: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, void, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionsToSubscriptionsMappingInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionsToSubscriptionsMappingInput = typeof PrivateStoreCollectionsToSubscriptionsMappingInput.Type;
export declare const PrivateStoreCollectionsToSubscriptionsMappingOutput: Schema.Struct<{
    readonly details: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
        readonly collectionName: Schema.optional<Schema.String>;
        readonly subscriptions: Schema.optional<Schema.$Array<Schema.String>>;
    }>>>;
}>;
export type PrivateStoreCollectionsToSubscriptionsMappingOutput = typeof PrivateStoreCollectionsToSubscriptionsMappingOutput.Type;
/**
 * For a given subscriptions list, the API will return a map of collections and the related subscriptions from the supplied list.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreCollectionsToSubscriptionsMapping: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly details?: {
        readonly [x: string]: {
            readonly collectionName?: string | undefined;
            readonly subscriptions?: readonly string[] | undefined;
        };
    } | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCollectionTransferOffersInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCollectionTransferOffersInput = typeof PrivateStoreCollectionTransferOffersInput.Type;
export declare const PrivateStoreCollectionTransferOffersOutput: Schema.Struct<{
    readonly succeeded: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly collectionName: Schema.optional<Schema.String>;
        readonly collectionId: Schema.optional<Schema.String>;
    }>>>;
    readonly failed: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly collectionName: Schema.optional<Schema.String>;
        readonly collectionId: Schema.optional<Schema.String>;
    }>>>;
}>;
export type PrivateStoreCollectionTransferOffersOutput = typeof PrivateStoreCollectionTransferOffersOutput.Type;
/**
 * transferring offers (copy or move) from source collection to target collection(s)
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const PrivateStoreCollectionTransferOffers: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, {
    readonly failed?: readonly {
        readonly collectionId?: string | undefined;
        readonly collectionName?: string | undefined;
    }[] | undefined;
    readonly succeeded?: readonly {
        readonly collectionId?: string | undefined;
        readonly collectionName?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCreateApprovalRequestInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly requestApprovalId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCreateApprovalRequestInput = typeof PrivateStoreCreateApprovalRequestInput.Type;
export declare const PrivateStoreCreateApprovalRequestOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreCreateApprovalRequestOutput = typeof PrivateStoreCreateApprovalRequestOutput.Type;
/**
 * Create approval request
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param requestApprovalId - The request approval ID to get create or update
 */
export declare const PrivateStoreCreateApprovalRequest: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
    readonly requestApprovalId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreCreateOrUpdateInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreCreateOrUpdateInput = typeof PrivateStoreCreateOrUpdateInput.Type;
export declare const PrivateStoreCreateOrUpdateOutput: Schema.Void;
export type PrivateStoreCreateOrUpdateOutput = typeof PrivateStoreCreateOrUpdateOutput.Type;
/**
 * Changes private store properties
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreCreateOrUpdate: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, void, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreDeleteInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreDeleteInput = typeof PrivateStoreDeleteInput.Type;
export declare const PrivateStoreDeleteOutput: Schema.Void;
export type PrivateStoreDeleteOutput = typeof PrivateStoreDeleteOutput.Type;
/**
 * Deletes the private store. All that is not saved will be lost.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreDelete: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, void, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreFetchAllSubscriptionsInTenantInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreFetchAllSubscriptionsInTenantInput = typeof PrivateStoreFetchAllSubscriptionsInTenantInput.Type;
export declare const PrivateStoreFetchAllSubscriptionsInTenantOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly subscriptionId: Schema.optional<Schema.String>;
        readonly displayName: Schema.optional<Schema.String>;
        readonly state: Schema.optional<Schema.Literals<readonly ["Enabled", "Warned", "PastDue", "Disabled", "Deleted"]>>;
    }>>>;
    readonly skipToken: Schema.optional<Schema.String>;
    readonly count: Schema.optional<Schema.Number>;
}>;
export type PrivateStoreFetchAllSubscriptionsInTenantOutput = typeof PrivateStoreFetchAllSubscriptionsInTenantOutput.Type;
/**
 * Fetch all subscriptions in tenant, only for marketplace admin
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param next-page-token - The skip token to get the next page.
 */
export declare const PrivateStoreFetchAllSubscriptionsInTenant: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly count?: number | undefined;
    readonly skipToken?: string | undefined;
    readonly value?: readonly {
        readonly displayName?: string | undefined;
        readonly id?: string | undefined;
        readonly state?: "Deleted" | "Disabled" | "Enabled" | "PastDue" | "Warned" | undefined;
        readonly subscriptionId?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreGetInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreGetInput = typeof PrivateStoreGetInput.Type;
export declare const PrivateStoreGetOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreGetOutput = typeof PrivateStoreGetOutput.Type;
/**
 * Get information about the private store
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreGet: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreGetAdminRequestApprovalInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly adminRequestApprovalId: Schema.String;
    readonly "api-version": Schema.String;
    readonly publisherId: Schema.String;
}>;
export type PrivateStoreGetAdminRequestApprovalInput = typeof PrivateStoreGetAdminRequestApprovalInput.Type;
export declare const PrivateStoreGetAdminRequestApprovalOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreGetAdminRequestApprovalOutput = typeof PrivateStoreGetAdminRequestApprovalOutput.Type;
/**
 * Get open approval requests
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param adminRequestApprovalId - The admin request approval ID to get create or update
 * @param publisherId - The publisher id of this offer.
 */
export declare const PrivateStoreGetAdminRequestApproval: import("@distilled.cloud/core/client").OperationMethod<{
    readonly adminRequestApprovalId: string;
    readonly "api-version": string;
    readonly privateStoreId: string;
    readonly publisherId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreGetApprovalRequestsListInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreGetApprovalRequestsListInput = typeof PrivateStoreGetApprovalRequestsListInput.Type;
export declare const PrivateStoreGetApprovalRequestsListOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
        readonly systemData: Schema.optional<Schema.Struct<{
            readonly createdBy: Schema.optional<Schema.String>;
            readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly createdAt: Schema.optional<Schema.String>;
            readonly lastModifiedBy: Schema.optional<Schema.String>;
            readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly lastModifiedAt: Schema.optional<Schema.String>;
        }>>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type PrivateStoreGetApprovalRequestsListOutput = typeof PrivateStoreGetApprovalRequestsListOutput.Type;
/**
 * Get all open approval requests of current user
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreGetApprovalRequestsList: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly systemData?: {
            readonly createdAt?: string | undefined;
            readonly createdBy?: string | undefined;
            readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
            readonly lastModifiedAt?: string | undefined;
            readonly lastModifiedBy?: string | undefined;
            readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        } | undefined;
        readonly type?: string | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreGetRequestApprovalInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly requestApprovalId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreGetRequestApprovalInput = typeof PrivateStoreGetRequestApprovalInput.Type;
export declare const PrivateStoreGetRequestApprovalOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreGetRequestApprovalOutput = typeof PrivateStoreGetRequestApprovalOutput.Type;
/**
 * Get open request approval details
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param requestApprovalId - The request approval ID to get create or update
 */
export declare const PrivateStoreGetRequestApproval: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
    readonly requestApprovalId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreListInput: Schema.Struct<{
    readonly "api-version": Schema.String;
    readonly "use-cache": Schema.optional<Schema.String>;
}>;
export type PrivateStoreListInput = typeof PrivateStoreListInput.Type;
export declare const PrivateStoreListOutput: Schema.Struct<{
    readonly value: Schema.$Array<Schema.Struct<{
        readonly id: Schema.optional<Schema.String>;
        readonly name: Schema.optional<Schema.String>;
        readonly type: Schema.optional<Schema.String>;
        readonly systemData: Schema.optional<Schema.Struct<{
            readonly createdBy: Schema.optional<Schema.String>;
            readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly createdAt: Schema.optional<Schema.String>;
            readonly lastModifiedBy: Schema.optional<Schema.String>;
            readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
            readonly lastModifiedAt: Schema.optional<Schema.String>;
        }>>;
    }>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type PrivateStoreListOutput = typeof PrivateStoreListOutput.Type;
/**
 * Gets the list of available private stores.
 *
 * @param api-version - The API version to use for this operation.
 * @param use-cache - Determines if to use cache or DB for serving this request
 */
export declare const PrivateStoreList: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly "use-cache"?: string | undefined;
}, {
    readonly nextLink?: string | undefined;
    readonly value: readonly {
        readonly id?: string | undefined;
        readonly name?: string | undefined;
        readonly systemData?: {
            readonly createdAt?: string | undefined;
            readonly createdBy?: string | undefined;
            readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
            readonly lastModifiedAt?: string | undefined;
            readonly lastModifiedBy?: string | undefined;
            readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        } | undefined;
        readonly type?: string | undefined;
    }[];
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreListNewPlansNotificationsInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreListNewPlansNotificationsInput = typeof PrivateStoreListNewPlansNotificationsInput.Type;
export declare const PrivateStoreListNewPlansNotificationsOutput: Schema.Struct<{
    readonly newPlansNotifications: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly offerId: Schema.optional<Schema.String>;
        readonly displayName: Schema.optional<Schema.String>;
        readonly isFuturePlansEnabled: Schema.optional<Schema.Boolean>;
        readonly messageCode: Schema.optional<Schema.Number>;
        readonly icon: Schema.optional<Schema.String>;
        readonly plans: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly planId: Schema.optional<Schema.String>;
            readonly planDisplayName: Schema.optional<Schema.String>;
        }>>>;
    }>>>;
}>;
export type PrivateStoreListNewPlansNotificationsOutput = typeof PrivateStoreListNewPlansNotificationsOutput.Type;
/**
 * List new plans notifications
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreListNewPlansNotifications: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly newPlansNotifications?: readonly {
        readonly displayName?: string | undefined;
        readonly icon?: string | undefined;
        readonly isFuturePlansEnabled?: boolean | undefined;
        readonly messageCode?: number | undefined;
        readonly offerId?: string | undefined;
        readonly plans?: readonly {
            readonly planDisplayName?: string | undefined;
            readonly planId?: string | undefined;
        }[] | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreListStopSellOffersPlansNotificationsInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreListStopSellOffersPlansNotificationsInput = typeof PrivateStoreListStopSellOffersPlansNotificationsInput.Type;
export declare const PrivateStoreListStopSellOffersPlansNotificationsOutput: Schema.Struct<{
    readonly stopSellNotifications: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly offerId: Schema.optional<Schema.String>;
        readonly displayName: Schema.optional<Schema.String>;
        readonly isEntire: Schema.optional<Schema.Boolean>;
        readonly messageCode: Schema.optional<Schema.Number>;
        readonly icon: Schema.optional<Schema.String>;
        readonly plans: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly planId: Schema.optional<Schema.String>;
            readonly planDisplayName: Schema.optional<Schema.String>;
        }>>>;
        readonly publicContext: Schema.optional<Schema.Boolean>;
        readonly subscriptionsIds: Schema.optional<Schema.$Array<Schema.String>>;
    }>>>;
}>;
export type PrivateStoreListStopSellOffersPlansNotificationsOutput = typeof PrivateStoreListStopSellOffersPlansNotificationsOutput.Type;
/**
 * List stop sell notifications for both stop sell offers and stop sell plans
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreListStopSellOffersPlansNotifications: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly stopSellNotifications?: readonly {
        readonly displayName?: string | undefined;
        readonly icon?: string | undefined;
        readonly isEntire?: boolean | undefined;
        readonly messageCode?: number | undefined;
        readonly offerId?: string | undefined;
        readonly plans?: readonly {
            readonly planDisplayName?: string | undefined;
            readonly planId?: string | undefined;
        }[] | undefined;
        readonly publicContext?: boolean | undefined;
        readonly subscriptionsIds?: readonly string[] | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreListSubscriptionsContextInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreListSubscriptionsContextInput = typeof PrivateStoreListSubscriptionsContextInput.Type;
export declare const PrivateStoreListSubscriptionsContextOutput: Schema.Struct<{
    readonly subscriptionsIds: Schema.optional<Schema.$Array<Schema.String>>;
}>;
export type PrivateStoreListSubscriptionsContextOutput = typeof PrivateStoreListSubscriptionsContextOutput.Type;
/**
 * List all the subscriptions in the private store context
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreListSubscriptionsContext: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly subscriptionsIds?: readonly string[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreQueryApprovedPlansInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreQueryApprovedPlansInput = typeof PrivateStoreQueryApprovedPlansInput.Type;
export declare const PrivateStoreQueryApprovedPlansOutput: Schema.Struct<{
    readonly details: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly planId: Schema.optional<Schema.String>;
        readonly subscriptionIds: Schema.optional<Schema.$Array<Schema.String>>;
        readonly allSubscriptions: Schema.optional<Schema.Boolean>;
    }>>>;
}>;
export type PrivateStoreQueryApprovedPlansOutput = typeof PrivateStoreQueryApprovedPlansOutput.Type;
/**
 * Get map of plans and related approved subscriptions.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreQueryApprovedPlans: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly details?: readonly {
        readonly allSubscriptions?: boolean | undefined;
        readonly planId?: string | undefined;
        readonly subscriptionIds?: readonly string[] | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreQueryNotificationsStateInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreQueryNotificationsStateInput = typeof PrivateStoreQueryNotificationsStateInput.Type;
export declare const PrivateStoreQueryNotificationsStateOutput: Schema.Struct<{
    readonly stopSellNotifications: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly offerId: Schema.optional<Schema.String>;
        readonly displayName: Schema.optional<Schema.String>;
        readonly isEntire: Schema.optional<Schema.Boolean>;
        readonly messageCode: Schema.optional<Schema.Number>;
        readonly icon: Schema.optional<Schema.String>;
        readonly plans: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly planId: Schema.optional<Schema.String>;
            readonly planDisplayName: Schema.optional<Schema.String>;
        }>>>;
    }>>>;
    readonly newNotifications: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly offerId: Schema.optional<Schema.String>;
        readonly displayName: Schema.optional<Schema.String>;
        readonly isFuturePlansEnabled: Schema.optional<Schema.Boolean>;
        readonly messageCode: Schema.optional<Schema.Number>;
        readonly icon: Schema.optional<Schema.String>;
        readonly plans: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly planId: Schema.optional<Schema.String>;
            readonly planDisplayName: Schema.optional<Schema.String>;
        }>>>;
    }>>>;
    readonly approvalRequests: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly offerId: Schema.optional<Schema.String>;
        readonly displayName: Schema.optional<Schema.String>;
        readonly publisherId: Schema.optional<Schema.String>;
        readonly messageCode: Schema.optional<Schema.Number>;
        readonly icon: Schema.optional<Schema.String>;
        readonly plans: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly planId: Schema.optional<Schema.String>;
            readonly planDisplayName: Schema.optional<Schema.String>;
        }>>>;
    }>>>;
}>;
export type PrivateStoreQueryNotificationsStateOutput = typeof PrivateStoreQueryNotificationsStateOutput.Type;
/**
 * Get private store notifications state
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreQueryNotificationsState: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly approvalRequests?: readonly {
        readonly displayName?: string | undefined;
        readonly icon?: string | undefined;
        readonly messageCode?: number | undefined;
        readonly offerId?: string | undefined;
        readonly plans?: readonly {
            readonly planDisplayName?: string | undefined;
            readonly planId?: string | undefined;
        }[] | undefined;
        readonly publisherId?: string | undefined;
    }[] | undefined;
    readonly newNotifications?: readonly {
        readonly displayName?: string | undefined;
        readonly icon?: string | undefined;
        readonly isFuturePlansEnabled?: boolean | undefined;
        readonly messageCode?: number | undefined;
        readonly offerId?: string | undefined;
        readonly plans?: readonly {
            readonly planDisplayName?: string | undefined;
            readonly planId?: string | undefined;
        }[] | undefined;
    }[] | undefined;
    readonly stopSellNotifications?: readonly {
        readonly displayName?: string | undefined;
        readonly icon?: string | undefined;
        readonly isEntire?: boolean | undefined;
        readonly messageCode?: number | undefined;
        readonly offerId?: string | undefined;
        readonly plans?: readonly {
            readonly planDisplayName?: string | undefined;
            readonly planId?: string | undefined;
        }[] | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreQueryOffersInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreQueryOffersInput = typeof PrivateStoreQueryOffersInput.Type;
export declare const PrivateStoreQueryOffersOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly uniqueOfferId: Schema.optional<Schema.String>;
        readonly offerDisplayName: Schema.optional<Schema.String>;
        readonly publisherDisplayName: Schema.optional<Schema.String>;
        readonly eTag: Schema.optional<Schema.String>;
        readonly privateStoreId: Schema.optional<Schema.String>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly modifiedAt: Schema.optional<Schema.String>;
        readonly specificPlanIdsLimitation: Schema.optional<Schema.$Array<Schema.String>>;
        readonly updateSuppressedDueIdempotence: Schema.optional<Schema.Boolean>;
        readonly iconFileUris: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
        readonly isStopSell: Schema.optional<Schema.Boolean>;
        readonly plans: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly skuId: Schema.optional<Schema.String>;
            readonly planId: Schema.optional<Schema.String>;
            readonly planDisplayName: Schema.optional<Schema.String>;
            readonly accessibility: Schema.optional<Schema.Literals<readonly ["Unknown", "Public", "PrivateTenantOnLevel", "PrivateSubscriptionOnLevel"]>>;
            readonly altStackReference: Schema.optional<Schema.String>;
            readonly stackType: Schema.optional<Schema.String>;
            readonly isStopSell: Schema.optional<Schema.Boolean>;
        }>>>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type PrivateStoreQueryOffersOutput = typeof PrivateStoreQueryOffersOutput.Type;
/**
 * List of offers, regardless the collections
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreQueryOffers: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly createdAt?: string | undefined;
        readonly eTag?: string | undefined;
        readonly iconFileUris?: {
            readonly [x: string]: string;
        } | undefined;
        readonly isStopSell?: boolean | undefined;
        readonly modifiedAt?: string | undefined;
        readonly offerDisplayName?: string | undefined;
        readonly plans?: readonly {
            readonly accessibility?: "PrivateSubscriptionOnLevel" | "PrivateTenantOnLevel" | "Public" | "Unknown" | undefined;
            readonly altStackReference?: string | undefined;
            readonly isStopSell?: boolean | undefined;
            readonly planDisplayName?: string | undefined;
            readonly planId?: string | undefined;
            readonly skuId?: string | undefined;
            readonly stackType?: string | undefined;
        }[] | undefined;
        readonly privateStoreId?: string | undefined;
        readonly publisherDisplayName?: string | undefined;
        readonly specificPlanIdsLimitation?: readonly string[] | undefined;
        readonly uniqueOfferId?: string | undefined;
        readonly updateSuppressedDueIdempotence?: boolean | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreQueryRequestApprovalInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly requestApprovalId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreQueryRequestApprovalInput = typeof PrivateStoreQueryRequestApprovalInput.Type;
export declare const PrivateStoreQueryRequestApprovalOutput: Schema.Struct<{
    readonly uniqueOfferId: Schema.optional<Schema.String>;
    readonly plansDetails: Schema.optional<Schema.$Record<Schema.String, Schema.Struct<{
        readonly planId: Schema.optional<Schema.String>;
        readonly status: Schema.optional<Schema.Literals<readonly ["Pending", "Rejected", "Approved", "None"]>>;
        readonly requestDate: Schema.optional<Schema.Unknown>;
        readonly justification: Schema.optional<Schema.String>;
        readonly subscriptionId: Schema.optional<Schema.String>;
        readonly subscriptionName: Schema.optional<Schema.String>;
    }>>>;
    readonly etag: Schema.optional<Schema.String>;
    readonly messageCode: Schema.optional<Schema.Number>;
}>;
export type PrivateStoreQueryRequestApprovalOutput = typeof PrivateStoreQueryRequestApprovalOutput.Type;
/**
 * Get request statuses foreach plan, this api is used as a complex GET action.
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param requestApprovalId - The request approval ID to get create or update
 */
export declare const PrivateStoreQueryRequestApproval: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
    readonly requestApprovalId: string;
}, {
    readonly etag?: string | undefined;
    readonly messageCode?: number | undefined;
    readonly plansDetails?: {
        readonly [x: string]: {
            readonly justification?: string | undefined;
            readonly planId?: string | undefined;
            readonly requestDate?: unknown;
            readonly status?: "Approved" | "None" | "Pending" | "Rejected" | undefined;
            readonly subscriptionId?: string | undefined;
            readonly subscriptionName?: string | undefined;
        };
    } | undefined;
    readonly uniqueOfferId?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreQueryUserOffersInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreQueryUserOffersInput = typeof PrivateStoreQueryUserOffersInput.Type;
export declare const PrivateStoreQueryUserOffersOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly uniqueOfferId: Schema.optional<Schema.String>;
        readonly offerDisplayName: Schema.optional<Schema.String>;
        readonly publisherDisplayName: Schema.optional<Schema.String>;
        readonly eTag: Schema.optional<Schema.String>;
        readonly privateStoreId: Schema.optional<Schema.String>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly modifiedAt: Schema.optional<Schema.String>;
        readonly specificPlanIdsLimitation: Schema.optional<Schema.$Array<Schema.String>>;
        readonly updateSuppressedDueIdempotence: Schema.optional<Schema.Boolean>;
        readonly iconFileUris: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
        readonly isStopSell: Schema.optional<Schema.Boolean>;
        readonly plans: Schema.optional<Schema.$Array<Schema.Struct<{
            readonly skuId: Schema.optional<Schema.String>;
            readonly planId: Schema.optional<Schema.String>;
            readonly planDisplayName: Schema.optional<Schema.String>;
            readonly accessibility: Schema.optional<Schema.Literals<readonly ["Unknown", "Public", "PrivateTenantOnLevel", "PrivateSubscriptionOnLevel"]>>;
            readonly altStackReference: Schema.optional<Schema.String>;
            readonly stackType: Schema.optional<Schema.String>;
            readonly isStopSell: Schema.optional<Schema.Boolean>;
        }>>>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type PrivateStoreQueryUserOffersOutput = typeof PrivateStoreQueryUserOffersOutput.Type;
/**
 * List of user's approved offers for the provided offers and subscriptions
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const PrivateStoreQueryUserOffers: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly createdAt?: string | undefined;
        readonly eTag?: string | undefined;
        readonly iconFileUris?: {
            readonly [x: string]: string;
        } | undefined;
        readonly isStopSell?: boolean | undefined;
        readonly modifiedAt?: string | undefined;
        readonly offerDisplayName?: string | undefined;
        readonly plans?: readonly {
            readonly accessibility?: "PrivateSubscriptionOnLevel" | "PrivateTenantOnLevel" | "Public" | "Unknown" | undefined;
            readonly altStackReference?: string | undefined;
            readonly isStopSell?: boolean | undefined;
            readonly planDisplayName?: string | undefined;
            readonly planId?: string | undefined;
            readonly skuId?: string | undefined;
            readonly stackType?: string | undefined;
        }[] | undefined;
        readonly privateStoreId?: string | undefined;
        readonly publisherDisplayName?: string | undefined;
        readonly specificPlanIdsLimitation?: readonly string[] | undefined;
        readonly uniqueOfferId?: string | undefined;
        readonly updateSuppressedDueIdempotence?: boolean | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreUpdateAdminRequestApprovalInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly adminRequestApprovalId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreUpdateAdminRequestApprovalInput = typeof PrivateStoreUpdateAdminRequestApprovalInput.Type;
export declare const PrivateStoreUpdateAdminRequestApprovalOutput: Schema.Struct<{
    readonly id: Schema.optional<Schema.String>;
    readonly name: Schema.optional<Schema.String>;
    readonly type: Schema.optional<Schema.String>;
    readonly systemData: Schema.optional<Schema.Struct<{
        readonly createdBy: Schema.optional<Schema.String>;
        readonly createdByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly createdAt: Schema.optional<Schema.String>;
        readonly lastModifiedBy: Schema.optional<Schema.String>;
        readonly lastModifiedByType: Schema.optional<Schema.Literals<readonly ["User", "Application", "ManagedIdentity", "Key"]>>;
        readonly lastModifiedAt: Schema.optional<Schema.String>;
    }>>;
}>;
export type PrivateStoreUpdateAdminRequestApprovalOutput = typeof PrivateStoreUpdateAdminRequestApprovalOutput.Type;
/**
 * Update the admin action, weather the request is approved or rejected and the approved plans
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param adminRequestApprovalId - The admin request approval ID to get create or update
 */
export declare const PrivateStoreUpdateAdminRequestApproval: import("@distilled.cloud/core/client").OperationMethod<{
    readonly adminRequestApprovalId: string;
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly id?: string | undefined;
    readonly name?: string | undefined;
    readonly systemData?: {
        readonly createdAt?: string | undefined;
        readonly createdBy?: string | undefined;
        readonly createdByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
        readonly lastModifiedAt?: string | undefined;
        readonly lastModifiedBy?: string | undefined;
        readonly lastModifiedByType?: "Application" | "Key" | "ManagedIdentity" | "User" | undefined;
    } | undefined;
    readonly type?: string | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const PrivateStoreWithdrawPlanInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly requestApprovalId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type PrivateStoreWithdrawPlanInput = typeof PrivateStoreWithdrawPlanInput.Type;
export declare const PrivateStoreWithdrawPlanOutput: Schema.Void;
export type PrivateStoreWithdrawPlanOutput = typeof PrivateStoreWithdrawPlanOutput.Type;
/**
 * Withdraw a user request approval on specific plan
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param requestApprovalId - The request approval ID to get create or update
 */
export declare const PrivateStoreWithdrawPlan: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
    readonly requestApprovalId: string;
}, void, never, import("../credentials.ts").Credentials>;
export declare const QueryRulesInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type QueryRulesInput = typeof QueryRulesInput.Type;
export declare const QueryRulesOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly type: Schema.optional<Schema.Literals<readonly ["PrivateProducts", "TermsAndCondition"]>>;
        readonly value: Schema.optional<Schema.$Array<Schema.String>>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type QueryRulesOutput = typeof QueryRulesOutput.Type;
/**
 * Get a list of all private store rules in the given private store and collection
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const QueryRules: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly type?: "PrivateProducts" | "TermsAndCondition" | undefined;
        readonly value?: readonly string[] | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const QueryUserRulesInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type QueryUserRulesInput = typeof QueryUserRulesInput.Type;
export declare const QueryUserRulesOutput: Schema.Struct<{
    readonly value: Schema.optional<Schema.$Array<Schema.Struct<{
        readonly type: Schema.optional<Schema.Literals<readonly ["PrivateProducts", "TermsAndCondition"]>>;
        readonly value: Schema.optional<Schema.$Array<Schema.String>>;
    }>>>;
    readonly nextLink: Schema.optional<Schema.String>;
}>;
export type QueryUserRulesOutput = typeof QueryUserRulesOutput.Type;
/**
 * All rules approved in the private store that are relevant for user subscriptions
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 */
export declare const QueryUserRules: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly privateStoreId: string;
}, {
    readonly nextLink?: string | undefined;
    readonly value?: readonly {
        readonly type?: "PrivateProducts" | "TermsAndCondition" | undefined;
        readonly value?: readonly string[] | undefined;
    }[] | undefined;
}, never, import("../credentials.ts").Credentials>;
export declare const SetCollectionRulesInput: Schema.Struct<{
    readonly privateStoreId: Schema.String;
    readonly collectionId: Schema.String;
    readonly "api-version": Schema.String;
}>;
export type SetCollectionRulesInput = typeof SetCollectionRulesInput.Type;
export declare const SetCollectionRulesOutput: Schema.Void;
export type SetCollectionRulesOutput = typeof SetCollectionRulesOutput.Type;
/**
 * Set rule for specific private store and collection
 *
 * @param api-version - The API version to use for this operation.
 * @param privateStoreId - The store ID - must use the tenant ID
 * @param collectionId - The collection ID
 */
export declare const SetCollectionRules: import("@distilled.cloud/core/client").OperationMethod<{
    readonly "api-version": string;
    readonly collectionId: string;
    readonly privateStoreId: string;
}, void, never, import("../credentials.ts").Credentials>;
//# sourceMappingURL=marketplace.d.ts.map