@feedmepos/mf-hrm-portal 2.1.1-dev → 2.1.1-dev.3

package/dist/src/api/approval-code/index.d.ts

@@ -0,0 +1,7 @@
+import type { IFdtoApprovalCode, IFdtoCreateApprovalCodeReq } from '@/types/approval-code';
+declare const ApprovalCodeAPI: {
+    getApprovalCodes(): Promise<IFdtoApprovalCode[]>;
+    createApprovalCodes(dto: IFdtoCreateApprovalCodeReq): Promise<IFdtoApprovalCode[]>;
+    revokeApprovalCode(id: string, restaurantId: string): Promise<IFdtoApprovalCode>;
+};
+export default ApprovalCodeAPI;

package/dist/src/api/audit-log/index.d.ts

@@ -9,9 +9,6 @@ declare const AuditLogAPI: {
         actions?: string[];
         outcomes?: string[];
         feedmeAdminActors?: boolean;
-        search?: string;
-        searchUserIds?: string[];
-        searchSubjects?: string[];
     }): Promise<number>;
     read(params?: {
         limit?: number;
@@ -24,9 +21,6 @@ declare const AuditLogAPI: {
         actions?: string[];
         outcomes?: string[];
         feedmeAdminActors?: boolean;
-        search?: string;
-        searchUserIds?: string[];
-        searchSubjects?: string[];
     }): Promise<AuditLogEntry[]>;
     /**
      * FeedMe-admin options for the User filter. `actors` is the named admin list (internal

package/dist/src/components/CheckboxInput.vue.d.ts

@@ -141,8 +141,8 @@ declare const __VLS_component: import("vue").DefineComponent<import("vue").Extra
 }>> & Readonly<{
     "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
 }>, {
-    min: number;
     max: number;
+    min: number;
     disable: boolean;
     showAllToggle: string | boolean;
     includeDisabledOptionsWhenSelectAll: boolean;

package/dist/src/components/button/ResponsiveFabButton.vue.d.ts

@@ -1,9 +1,3 @@
 import { type FmButtonProps } from '@feedmepos/ui-library';
-interface Props extends FmButtonProps {
-    /** Whether the page has a fixed bottom footer (e.g. a pagination bar) the mobile FAB should raise above. */
-    hasFooterBelow?: boolean;
-}
-declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
-    hasFooterBelow: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: import("vue").DefineComponent<FmButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FmButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/src/components/table/TableEmptyState.vue.d.ts

@@ -5,22 +5,30 @@ interface Props {
     isEmpty: boolean;
     isLoading?: boolean;
     /**
-     * At what width do the column titles disappear? Below/at this breakpoint the message is
-     * styled as a standalone bordered card instead of blending flat under the table header. Must
-     * mirror the wrapped FmTable's own `shrink-at` prop (both default to "sm"); pass `false` if
-     * the table never collapses.
+     * At what width do the column titles disappear? The table's column labels are gone at/below
+     * this breakpoint, so the empty state should move outside instead of overlaying the table
+     * body. Must mirror the wrapped FmTable's own `shrink-at` prop (both default to "sm"); pass
+     * `false` if the table never collapses.
      */
     collapseAt?: Breakpoints | false;
+    /**
+     * At what width do we hide the table completely because there's a separate mobile view taking
+     * over? For callers that render their own alternate view (e.g. a mobile FmList) at/below this
+     * breakpoint. Pass `false` if the table has no alternate view and should stay visible at every
+     * breakpoint.
+     */
+    hideTableBelow?: Breakpoints | false;
 }
-declare var __VLS_1: {
-    isEmpty: boolean;
+declare var __VLS_5: {
+    isTableCollapsed: boolean;
 };
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_1) => any;
+    default?: (props: typeof __VLS_5) => any;
 };
 declare const __VLS_component: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
     isLoading: boolean;
     collapseAt: Breakpoints | false;
+    hideTableBelow: Breakpoints | false;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/src/composables/useBasePermission.d.ts

@@ -7,7 +7,6 @@ export type CategoryGroup = {
     options: {
         label: string;
         value: string;
-        optionKey: string;
     }[];
     selectedSubjects: string[];
     isMultiAction: boolean;
@@ -26,7 +25,7 @@ export declare function useBasePermission(modelValue: Readonly<Ref<FdoPermission
     toggleAllManage: (group: CategoryGroup) => void;
     isManageChecked: (group: CategoryGroup, subject: string) => boolean;
     isManageIndeterminate: (group: CategoryGroup, subject: string) => boolean;
-    toggleManage: (group: CategoryGroup, subject: string, checked: boolean) => void;
+    toggleManage: (_group: CategoryGroup, subject: string, checked: boolean) => void;
     hasNonManageActions: (group: CategoryGroup, subject: string) => boolean;
     isActionChecked: (group: CategoryGroup, subject: string, action: string) => boolean;
     isRowFullyCoveredByCover: (group: CategoryGroup, subject: string) => boolean;

package/dist/src/helpers/permission-set.d.ts

@@ -71,14 +71,10 @@ export declare function filterStalePermissions(permissions: FdoPermissionRule[],
  * `allCustomReports` positive grant, preventing redundant data from being saved.
  *
  * - If the cover rule has `manage` selected → every individual rule in that bucket is
- *   fully covered and dropped entirely only when the cover condition also covers the
- *   individual rule.
- * - Otherwise, only covered non-manage actions are stripped from individual rules when
- *   the cover condition also covers the individual rule.
- *   `manage` is a real CASL wildcard grant that implies every action, not merely a
- *   shorthand for "all non-manage actions selected" — a rule carrying `manage` is
- *   pushed through UNCHANGED (a cover lacking `manage` cannot cover it). Stripping its
- *   constituent actions and then dropping `manage` would destroy the user's grant.
+ *   fully covered and dropped entirely.
+ * - Otherwise, only covered non-manage actions are stripped from individual rules.
+ *   If `manage` was present and any non-manage action is stripped (breaking the
+ *   "manage = all non-manage selected" invariant), `manage` is also stripped.
  *   Rules that end up with no remaining actions are dropped.
  *
  * Inverted rules and the cover subjects themselves pass through untouched.

package/dist/src/helpers/rule.d.ts

@@ -20,8 +20,7 @@ export declare function getMaxDiscount(rules: FdoPermissionRule[]): number;
 export declare function getManagableRestaurantIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
 export declare function hasAdminRule(rules: FdoPermissionRule[]): boolean;
 export declare function usableRoleIds(rules: (FdoPermissionRule | RawRule)[]): string[] | null;
-export declare function extractReportExtraCondition(rule: FdoPermissionRule): Record<string, unknown> | undefined;
-export declare function fromValue(values: string[], maxDiscountPercentage: number, periodConditions?: Map<string, Record<string, unknown>>): {
+export declare function fromValue(values: string[], maxDiscountPercentage: number): {
     subject: string;
     actions: ("delete" | "create" | "update" | "read" | "manage")[];
     conditions: object;

package/dist/src/router/shared.d.ts

@@ -8,7 +8,9 @@ export declare enum RouteName {
     TEAM = "team",
     TEAM_MEMBER = "team-member",
     TEAM_ROLE = "team-role",
-    POS_GRANT = "pos-grant"
+    POS_ACCESS = "pos-access",
+    POS_GRANT = "pos-grant",
+    APPROVAL_CODE = "approval-code"
 }
 declare const routes: RouteRecordRaw[];
 export { routes };

package/dist/src/stores/approval-code.d.ts

@@ -0,0 +1,140 @@
+import type { IFdtoApprovalCode, IFdtoCreateApprovalCodeReq } from '@/types/approval-code';
+export declare const useApprovalCodeStore: import("pinia").StoreDefinition<"approvalCode", Pick<{
+    approvalCodes: import("vue").Ref<{
+        _id: string;
+        businessId: string;
+        restaurantId: string;
+        passcode: string;
+        name: string;
+        type: "approval";
+        permissions: {
+            key: import("@/types/approval-code").ApprovalCodePermission;
+            subject: string;
+            actions: string[];
+            conditions?: Record<string, unknown> | undefined;
+        }[];
+        status: "active" | "used" | "revoked";
+        usedAt?: string | undefined;
+        revokedAt?: string | undefined;
+        grantById: string;
+        grantByName: string;
+        createdAt: string;
+        updatedAt: string;
+    }[], IFdtoApprovalCode[] | {
+        _id: string;
+        businessId: string;
+        restaurantId: string;
+        passcode: string;
+        name: string;
+        type: "approval";
+        permissions: {
+            key: import("@/types/approval-code").ApprovalCodePermission;
+            subject: string;
+            actions: string[];
+            conditions?: Record<string, unknown> | undefined;
+        }[];
+        status: "active" | "used" | "revoked";
+        usedAt?: string | undefined;
+        revokedAt?: string | undefined;
+        grantById: string;
+        grantByName: string;
+        createdAt: string;
+        updatedAt: string;
+    }[]>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    readApprovalCodes: () => Promise<void>;
+    createApprovalCodes: (dto: IFdtoCreateApprovalCodeReq) => Promise<IFdtoApprovalCode[]>;
+    revokeApprovalCode: (id: string, restaurantId: string) => Promise<void>;
+}, "isLoading" | "approvalCodes">, Pick<{
+    approvalCodes: import("vue").Ref<{
+        _id: string;
+        businessId: string;
+        restaurantId: string;
+        passcode: string;
+        name: string;
+        type: "approval";
+        permissions: {
+            key: import("@/types/approval-code").ApprovalCodePermission;
+            subject: string;
+            actions: string[];
+            conditions?: Record<string, unknown> | undefined;
+        }[];
+        status: "active" | "used" | "revoked";
+        usedAt?: string | undefined;
+        revokedAt?: string | undefined;
+        grantById: string;
+        grantByName: string;
+        createdAt: string;
+        updatedAt: string;
+    }[], IFdtoApprovalCode[] | {
+        _id: string;
+        businessId: string;
+        restaurantId: string;
+        passcode: string;
+        name: string;
+        type: "approval";
+        permissions: {
+            key: import("@/types/approval-code").ApprovalCodePermission;
+            subject: string;
+            actions: string[];
+            conditions?: Record<string, unknown> | undefined;
+        }[];
+        status: "active" | "used" | "revoked";
+        usedAt?: string | undefined;
+        revokedAt?: string | undefined;
+        grantById: string;
+        grantByName: string;
+        createdAt: string;
+        updatedAt: string;
+    }[]>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    readApprovalCodes: () => Promise<void>;
+    createApprovalCodes: (dto: IFdtoCreateApprovalCodeReq) => Promise<IFdtoApprovalCode[]>;
+    revokeApprovalCode: (id: string, restaurantId: string) => Promise<void>;
+}, never>, Pick<{
+    approvalCodes: import("vue").Ref<{
+        _id: string;
+        businessId: string;
+        restaurantId: string;
+        passcode: string;
+        name: string;
+        type: "approval";
+        permissions: {
+            key: import("@/types/approval-code").ApprovalCodePermission;
+            subject: string;
+            actions: string[];
+            conditions?: Record<string, unknown> | undefined;
+        }[];
+        status: "active" | "used" | "revoked";
+        usedAt?: string | undefined;
+        revokedAt?: string | undefined;
+        grantById: string;
+        grantByName: string;
+        createdAt: string;
+        updatedAt: string;
+    }[], IFdtoApprovalCode[] | {
+        _id: string;
+        businessId: string;
+        restaurantId: string;
+        passcode: string;
+        name: string;
+        type: "approval";
+        permissions: {
+            key: import("@/types/approval-code").ApprovalCodePermission;
+            subject: string;
+            actions: string[];
+            conditions?: Record<string, unknown> | undefined;
+        }[];
+        status: "active" | "used" | "revoked";
+        usedAt?: string | undefined;
+        revokedAt?: string | undefined;
+        grantById: string;
+        grantByName: string;
+        createdAt: string;
+        updatedAt: string;
+    }[]>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    readApprovalCodes: () => Promise<void>;
+    createApprovalCodes: (dto: IFdtoCreateApprovalCodeReq) => Promise<IFdtoApprovalCode[]>;
+    revokeApprovalCode: (id: string, restaurantId: string) => Promise<void>;
+}, "readApprovalCodes" | "createApprovalCodes" | "revokeApprovalCode">>;

package/dist/src/stores/permission-set.d.ts

@@ -1,6 +1,5 @@
 import type { IFdtoPermissionSet, IFdtoCreatePermissionSetReq, IFdtoUpdatePermissionSetReq } from '@/types/permission-set';
 export declare const usePermissionSetStore: () => {
-    isLoading: import("vue").Ref<boolean, boolean>;
     permissionSets: import("vue").Ref<{
         id: string;
         permissions: {
@@ -31,7 +30,6 @@ export declare const usePermissionSetStore: () => {
         name: string;
     }[]>;
     $state: {
-        isLoading: boolean;
         permissionSets: {
             id: string;
             permissions: {
@@ -77,14 +75,12 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
-        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
         deletePermissionSet: (id: string) => Promise<void>;
-    }, "isLoading" | "permissionSets">>;
+    }, "permissionSets">>;
     $patch(partialState: import("pinia")._DeepPartial<{
-        isLoading: boolean;
         permissionSets: {
             id: string;
             permissions: {
@@ -102,7 +98,6 @@ export declare const usePermissionSetStore: () => {
         }[];
     }>): void;
     $patch<F extends (state: {
-        isLoading: boolean;
         permissionSets: {
             id: string;
             permissions: {
@@ -150,12 +145,11 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
-        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
         deletePermissionSet: (id: string) => Promise<void>;
-    }, "isLoading" | "permissionSets">>, options?: {
+    }, "permissionSets">>, options?: {
         detached?: boolean;
     } & import("vue").WatchOptions): () => void;
     $onAction(callback: import("pinia").StoreOnActionListener<"permissionSet", Pick<{
@@ -188,12 +182,11 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
-        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
         deletePermissionSet: (id: string) => Promise<void>;
-    }, "isLoading" | "permissionSets">, Pick<{
+    }, "permissionSets">, Pick<{
         permissionSets: import("vue").Ref<{
             id: string;
             permissions: {
@@ -223,7 +216,6 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
-        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;
@@ -258,7 +250,6 @@ export declare const usePermissionSetStore: () => {
             businessId: string;
             name: string;
         }[]>;
-        isLoading: import("vue").Ref<boolean, boolean>;
         readPermissionSets: () => Promise<void>;
         createPermissionSet: (dto: IFdtoCreatePermissionSetReq) => Promise<void>;
         updatePermissionSet: (id: string, dto: IFdtoUpdatePermissionSetReq) => Promise<void>;

package/dist/src/types/approval-code.d.ts

@@ -0,0 +1,99 @@
+export declare const APPROVAL_CODE_PERMISSIONS: readonly ["void", "refund", "discount", "changePrice", "claimDeposit", "payment", "resend", "changePaymentType", "openDrawer", "openCounter", "closeCounter", "printReceipt"];
+export type ApprovalCodePermission = (typeof APPROVAL_CODE_PERMISSIONS)[number];
+/**
+ * A single CASL-shaped rule keyed by the approval-code action it grants, as
+ * stored/returned by the backend. Mirrors `FdoApprovalCodeRule` from
+ * `apps/hrm-backend/src/grant-user/grant-user.entity.ts`.
+ */
+export interface IFdtoApprovalCodeRule {
+    key: ApprovalCodePermission;
+    subject: string;
+    actions: string[];
+    conditions?: Record<string, unknown>;
+}
+/**
+ * The rule template (subject/actions/conditions, minus `key`) for every
+ * approval-code permission the portal can grant. The portal is now the
+ * owner of these shapes (KDI-4982 Task A2) — the backend only validates the
+ * shape of whatever rule it receives, it no longer composes rules itself.
+ * These values were copied verbatim from the backend's server-side
+ * key-to-rule manifest before it was deleted; they must keep matching
+ * `FdoApprovalCodeRule`'s shape validation in
+ * `apps/hrm-backend/src/grant-user/grant-user.entity.ts`.
+ */
+export declare const APPROVAL_CODE_RULE_TEMPLATES: Record<ApprovalCodePermission, {
+    subject: string;
+    actions: string[];
+    conditions: Record<string, unknown>;
+}>;
+/**
+ * Compose the full CASL-shaped rule for `key`, ready to send to the backend
+ * as-is. Only `discount` honors `params.maxPercentage`, appending it as an
+ * `adjustment: { $lte: maxPercentage / 100 } }` condition — every other key
+ * ignores `params` if passed, matching the deleted backend manifest's
+ * `buildRule` behavior.
+ */
+export declare function buildApprovalCodeRule(key: ApprovalCodePermission, params?: {
+    maxPercentage?: number;
+}): IFdtoApprovalCodeRule;
+export interface IFdtoApprovalCode {
+    _id: string;
+    businessId: string;
+    restaurantId: string;
+    passcode: string;
+    name: string;
+    type: 'approval';
+    permissions: IFdtoApprovalCodeRule[];
+    status: 'active' | 'used' | 'revoked';
+    usedAt?: string;
+    revokedAt?: string;
+    grantById: string;
+    grantByName: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface IFdtoCreateApprovalCodeReq {
+    name: string;
+    restaurantId: string;
+    permissions: IFdtoApprovalCodeRule[];
+    count: number;
+}
+/**
+ * Read the discount ceiling back out of a rule's `conditions.adjustment.$lte`
+ * fraction (0-1) as a whole percentage (1-100). Returns `undefined` when the
+ * rule has no adjustment ceiling.
+ */
+export declare function getRuleAdjustmentCeilingPercentage(rule: IFdtoApprovalCodeRule): number | undefined;
+/**
+ * Validate the optional discount max-percentage input. Undefined, empty, or
+ * whitespace-only means "no ceiling" and is valid; otherwise the value must
+ * be an integer in `[1, 100]`.
+ */
+export declare function validateMaxPercentage(value: number | string | undefined): boolean;
+/**
+ * Resolve the discount max-percentage input into a definite number for the
+ * create-request payload, or `undefined` when it represents "no ceiling".
+ * Assumes the value has already passed `validateMaxPercentage`.
+ */
+export declare function resolveMaxPercentage(value: number | string | undefined): number | undefined;
+/**
+ * A selectable action option in the create form / list filter (KDI-4982 UI
+ * redesign). The 8 options mirror the POS v7 passcode prompts exactly:
+ * `changePrice`, `claimDeposit`, `payment` are not offered (the latter two
+ * have no passcode prompt on POS v7 at all), and open/close counter share one
+ * option because POS guards both with the same `counterRecord` permission.
+ * The 12-key `APPROVAL_CODE_PERMISSIONS` enum is untouched — stored rules and
+ * the wire format still use the full key set, so legacy codes keep rendering.
+ */
+export interface AccessCodeActionOption {
+    key: 'printReceipt' | 'resend' | 'openDrawer' | 'counter' | 'discount' | 'void' | 'changePaymentType' | 'refund';
+    ruleKeys: ApprovalCodePermission[];
+}
+export type AccessCodeActionOptionKey = AccessCodeActionOption['key'];
+export declare const ACCESS_CODE_ACTION_OPTIONS: AccessCodeActionOption[];
+/** When a code stopped being usable: used wins over revoked (a code can only
+ * be one or the other, but usedAt is the historically-populated field). */
+export declare function getResolvedAt(code: Pick<IFdtoApprovalCode, 'usedAt' | 'revokedAt'>): string | undefined;
+/** List-filter predicate: does this code grant any of the selected options?
+ * Empty/undefined selection means "no filter". */
+export declare function codeMatchesActionFilter(code: Pick<IFdtoApprovalCode, 'permissions'>, selected: AccessCodeActionOptionKey[] | undefined): boolean;

package/dist/src/types/audit-log.d.ts

@@ -1 +1 @@
-export type { AuditLogEntry, AuditLogMetadata, AuditLogOperation, AuditLogOutcome, AuditLogResolvedFrom, } from '@feedmepos/hrm-permission';
+export type { AuditLogEntry, AuditLogMetadata, AuditLogOutcome, AuditLogResolvedFrom } from '@feedmepos/hrm-permission';

package/dist/src/views/approval-code/ApprovalCodeList.vue.d.ts

@@ -0,0 +1,26 @@
+declare function create(): void;
+declare const _default: import("vue").DefineComponent<{}, {
+    create: typeof create;
+    filteredApprovalCodes: import("vue").ComputedRef<{
+        _id: string;
+        businessId: string;
+        restaurantId: string;
+        passcode: string;
+        name: string;
+        type: "approval";
+        permissions: {
+            key: import("@/types/approval-code").ApprovalCodePermission;
+            subject: string;
+            actions: string[];
+            conditions?: Record<string, unknown> | undefined;
+        }[];
+        status: "active" | "used" | "revoked";
+        usedAt?: string | undefined;
+        revokedAt?: string | undefined;
+        grantById: string;
+        grantByName: string;
+        createdAt: string;
+        updatedAt: string;
+    }[]>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/views/approval-code/components/ApprovalCodeForm.vue.d.ts

@@ -0,0 +1,17 @@
+declare var __VLS_1: {
+    trigger: () => void;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{}, {
+    show: import("vue").Ref<boolean, boolean>;
+    trigger: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};