@myparcel-dev/pdk-admin 2.1.0 → 2.2.1

package/dist/pdk/sendBootEvent.d.ts

@@ -0,0 +1,3 @@
+import { type AdminContextObject } from '../types';
+import { type PdkAdmin } from './PdkAdmin';
+export declare const sendBootEvent: (pdkAdmin: PdkAdmin, context: AdminContextObject) => void;

package/dist/pdk/setupAdminApp.d.ts

@@ -0,0 +1,3 @@
+import { type App } from 'vue';
+import { type AdminAppConfig } from '../types';
+export declare const setupAdminApp: (app: App<Element>, appConfig: AdminAppConfig) => void;

package/dist/pdk/testIdDirective.d.ts

@@ -0,0 +1,5 @@
+import { type Directive } from 'vue';
+import { type AnyElementInstance } from '@myparcel-dev/vue-form-builder';
+type TestIdBinding = string | string[] | [string, AnyElementInstance];
+export declare const testIdDirective: Directive<Element, TestIdBinding>;
+export {};

package/dist/sdk/PdkFetchClient.d.ts

@@ -0,0 +1,11 @@
+import { type AbstractEndpoint, type EndpointResponse, FetchClient, type Options } from '@myparcel-dev/sdk';
+export declare class PdkFetchClient extends FetchClient {
+    /**
+     * Prepare and execute the final request and handle the response.
+     */
+    doRequest<E extends AbstractEndpoint>(endpoint: E, options: Options<E>): Promise<EndpointResponse<E>>;
+    /**
+     * If the url already contains a query string, append the parameters with an ampersand instead.
+     */
+    protected createUrl<E extends AbstractEndpoint>(endpoint: E, options: Options<E>): string;
+}

package/dist/sdk/composables/api/index.d.ts

@@ -0,0 +1 @@
+export * from './useFetchCarrier';

package/dist/sdk/composables/api/useFetchCarrier.d.ts

@@ -0,0 +1 @@
+export declare const useFetchCarrier: (carrier?: string | number) => import("@tanstack/vue-query").UseQueryReturnType<import("@myparcel-dev/sdk").Carrier, unknown>;

package/dist/sdk/composables/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './useMyParcelApi';
+export * from './usePdkAdminApi';

package/dist/sdk/composables/useMyParcelApi.d.ts

@@ -0,0 +1,5 @@
+import { GetCarrier, GetCarriers, type MyParcelSdk } from '@myparcel-dev/sdk';
+/**
+ * @returns {MyParcelSdk<GetCarrier | GetCarriers>}
+ */
+export declare const useMyParcelApi: () => MyParcelSdk<GetCarrier | GetCarriers>;

package/dist/sdk/composables/usePdkAdminApi.d.ts

@@ -0,0 +1,6 @@
+import { type MyParcelSdk } from '@myparcel-dev/sdk';
+import { AbstractPdkEndpoint } from '../endpoints';
+/**
+ * Do requests to the PDK admin Api.
+ */
+export declare const usePdkAdminApi: () => MyParcelSdk<AbstractPdkEndpoint>;

package/dist/sdk/endpoints/abstractPdkEndpoint.d.ts

@@ -0,0 +1,7 @@
+import { type BackendEndpoint, type ExtractEndpointDefinition } from '@myparcel-dev/pdk-common';
+import { AbstractEndpoint } from '@myparcel-dev/sdk';
+import { type BackendEndpointDefinition } from '../../types';
+export declare abstract class AbstractPdkEndpoint<N extends BackendEndpoint = BackendEndpoint> extends AbstractEndpoint<ExtractEndpointDefinition<N, BackendEndpointDefinition>> {
+    readonly name: N | `${N}}`;
+    readonly path: string;
+}

package/dist/sdk/endpoints/index.d.ts

@@ -0,0 +1 @@
+export * from './abstractPdkEndpoint';

package/dist/sdk/index.d.ts

@@ -0,0 +1,3 @@
+export * from './PdkFetchClient';
+export * from './composables';
+export * from './endpoints';

package/dist/services/actions/createAction.d.ts

@@ -0,0 +1,4 @@
+import { type AnyActionDefinition, type ResolvedAction } from '../../types';
+type CreateAction = (action: AnyActionDefinition) => ResolvedAction;
+export declare const createAction: CreateAction;
+export {};

package/dist/services/actions/createActionContext.d.ts

@@ -0,0 +1,3 @@
+import { type ActionParameters, type AdminInstance, type AnyActionDefinition, type MaybeAdminAction } from '../../types';
+import { type ActionContext } from '../../actions';
+export declare const createActionContext: <A extends MaybeAdminAction>(action: AnyActionDefinition<A>, parameters?: ActionParameters<A>, existingInstance?: AdminInstance) => ActionContext<A>;

package/dist/services/actions/downloadFile.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Try to get a file from an url. An error means the file is not ready yet. Retry until it is.
+ */
+export declare function downloadFile(url: string, filename: string): Promise<void>;

package/dist/services/actions/getActionIdentifier.d.ts

@@ -0,0 +1,2 @@
+import { type AnyActionDefinition } from '../../types';
+export declare const getActionIdentifier: (action: AnyActionDefinition) => string;

package/dist/services/actions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './createAction';
+export * from './createActionContext';
+export * from './downloadFile';
+export * from './getActionIdentifier';

package/dist/services/addErrorToNotifications.d.ts

@@ -0,0 +1,2 @@
+import { type NotificationCategory } from '../data';
+export declare const addErrorToNotifications: (error: unknown, category: NotificationCategory, timeout?: boolean | number) => void;

package/dist/services/context/getElementContext.d.ts

@@ -0,0 +1,2 @@
+import { type AdminContextObject } from '../../types';
+export declare const getElementContext: (selector: string) => AdminContextObject;

package/dist/services/context/index.d.ts

@@ -0,0 +1 @@
+export * from './getElementContext';

package/dist/services/createNotification.d.ts

@@ -0,0 +1,5 @@
+import { type Variant } from '@myparcel-dev/pdk-common';
+import { type PdkNotification } from '../types';
+export declare const createNotification: (variant: Variant, options?: Partial<PdkNotification> & {
+    identifier?: string;
+}) => undefined | PdkNotification;

package/dist/services/index.d.ts

@@ -0,0 +1,9 @@
+export * from './actions';
+export * from './addErrorToNotifications';
+export * from './context';
+export * from './createNotification';
+export * from './instantiateAction';
+export * from './instantiateActions';
+export * from './logger';
+export * from './mutations';
+export * from './print';

package/dist/services/instantiateAction.d.ts

@@ -0,0 +1,2 @@
+import { type ActionDefinition, type ActionParameters, type AnyActionDefinition, type MaybeAdminAction } from '../types';
+export declare const instantiateAction: <A extends MaybeAdminAction>(action: AnyActionDefinition<A>, parameters?: ActionParameters<A>) => ActionDefinition<A>;

package/dist/services/instantiateActions.d.ts

@@ -0,0 +1,8 @@
+import { type ActionDefinition, type ActionParameters, type AnyActionDefinition } from '../types';
+import { type AdminAction } from '../data';
+type InstantiateActions = {
+    (action: AnyActionDefinition, parameters?: ActionParameters<AdminAction>): ActionDefinition[];
+    (actions: AnyActionDefinition[], parameters?: ActionParameters<AdminAction>): ActionDefinition[];
+};
+export declare const instantiateActions: InstantiateActions;
+export {};

package/dist/services/logger.d.ts

@@ -0,0 +1,19 @@
+export declare enum LogLevel {
+    Debug = 1,
+    Info = 2,
+    Warn = 3,
+    Error = 4,
+    Off = 5
+}
+export interface PdkLogger {
+    level: LogLevel;
+    scope: string | null;
+    debug(...messages: any[]): void;
+    error(...messages: any[]): void;
+    info(...messages: any[]): void;
+    log(level: LogLevel, ...messages: any[]): void;
+    setScope(scope: string | null): void;
+    warn(...messages: any[]): void;
+}
+export declare const globalLogger: PdkLogger;
+export declare const createLogger: (scope?: string | null, logLevel?: LogLevel | null) => PdkLogger;

package/dist/services/mutations/getCallbackForMutationMode.d.ts

@@ -0,0 +1,4 @@
+import { MutationMode } from './mutationMode';
+type Callback = (() => void) | undefined;
+export declare const getCallbackForMutationMode: (mode: MutationMode) => Callback;
+export {};

package/dist/services/mutations/getModalMutationOptions.d.ts

@@ -0,0 +1,2 @@
+import { type MutationOptions } from '@tanstack/vue-query';
+export declare const getModalMutationOptions: <TData = unknown, TError = unknown, TVariables = void, TContext = unknown>() => MutationOptions<TData, TError, TVariables, TContext>;

package/dist/services/mutations/index.d.ts

@@ -0,0 +1,3 @@
+export * from './getCallbackForMutationMode';
+export * from './getModalMutationOptions';
+export * from './mutationMode';

package/dist/services/mutations/mutationMode.d.ts

@@ -0,0 +1,4 @@
+export declare enum MutationMode {
+    Modal = "modal",
+    Default = "default"
+}

package/dist/services/print/index.d.ts

@@ -0,0 +1 @@
+export * from './openPdfInNewWindow';

package/dist/services/print/openPdfInNewWindow.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Opens a new window with the given base64 encoded pdf.
+ */
+export declare const openPdfInNewWindow: (pdf: string) => Promise<void>;

package/dist/stores/createQueryCacheKey.d.ts

@@ -0,0 +1,3 @@
+import { type BackendEndpoint } from '@myparcel-dev/pdk-common';
+import { type PlainModifier } from '../actions';
+export declare const createQueryCacheKey: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => string;

package/dist/stores/index.d.ts

@@ -0,0 +1,6 @@
+export * from './createQueryCacheKey';
+export * from './types';
+export * from './useActionStore';
+export * from './useModalStore';
+export * from './useNotificationStore';
+export * from './useQueryStore';

package/dist/stores/types.d.ts

@@ -0,0 +1,13 @@
+import { type UseMutationReturnType, type UseQueryReturnType } from '@tanstack/vue-query';
+import { type AdminContextKey, type BackendEndpoint } from '@myparcel-dev/pdk-common';
+import { type ApiException } from '@myparcel-dev/sdk';
+import { type ActionInput, type AdminContext, type BackendEndpointResponse, type BackendMutationEndpoints, type BackendQueryEndpoints } from '../types';
+import { type QueryModifier } from '../actions';
+type EndpointQuery<E extends BackendEndpoint> = E extends BackendMutationEndpoints ? UseMutationReturnType<BackendEndpointResponse<E>, ApiException, ActionInput<E>, unknown> : E extends BackendQueryEndpoints ? UseQueryReturnType<BackendEndpointResponse<E>, ApiException> : never;
+export type ContextQuery<C extends AdminContextKey = AdminContextKey.Dynamic> = UseQueryReturnType<AdminContext<C>, ApiException>;
+export type ResolvedQuery<E extends BackendEndpoint = BackendEndpoint> = E extends BackendEndpoint ? EndpointQuery<E> : never;
+export type RegisterQuery = {
+    <E extends BackendEndpoint, Q extends ResolvedQuery<E> = ResolvedQuery<E>>(endpoint: E, query: Q, arg3?: never): Q;
+    <E extends BackendEndpoint, Q extends ResolvedQuery<E> = ResolvedQuery<E>>(endpoint: E, modifier: QueryModifier<E>, query: Q): Q;
+};
+export {};

package/dist/stores/useActionStore.d.ts

@@ -0,0 +1,25 @@
+import { type OneOrMore, type PromiseOr } from '@myparcel-dev/ts-utils';
+import { type ActionParameters, type AnyActionDefinition, type ResolvedAction } from '../types';
+import { type AdminAction } from '../data';
+export declare const useActionStore: import("pinia").StoreDefinition<"actions", import("pinia")._UnwrapAll<Pick<{
+    get: (action: string | AdminAction) => ResolvedAction | undefined;
+    register: (action: OneOrMore<AnyActionDefinition>) => void;
+    dispatch: <A extends string | AdminAction>(action: A, parameters?: ActionParameters<A>) => PromiseOr<void>;
+    registerOrderActions: () => void;
+    registerModalActions: () => void;
+    registerWebhookActions: () => void;
+}, never>>, Pick<{
+    get: (action: string | AdminAction) => ResolvedAction | undefined;
+    register: (action: OneOrMore<AnyActionDefinition>) => void;
+    dispatch: <A extends string | AdminAction>(action: A, parameters?: ActionParameters<A>) => PromiseOr<void>;
+    registerOrderActions: () => void;
+    registerModalActions: () => void;
+    registerWebhookActions: () => void;
+}, never>, Pick<{
+    get: (action: string | AdminAction) => ResolvedAction | undefined;
+    register: (action: OneOrMore<AnyActionDefinition>) => void;
+    dispatch: <A extends string | AdminAction>(action: A, parameters?: ActionParameters<A>) => PromiseOr<void>;
+    registerOrderActions: () => void;
+    registerModalActions: () => void;
+    registerWebhookActions: () => void;
+}, "get" | "register" | "dispatch" | "registerOrderActions" | "registerModalActions" | "registerWebhookActions">>;

package/dist/stores/useModalStore.d.ts

@@ -0,0 +1,16 @@
+import { type Ref, type UnwrapNestedRefs } from 'vue';
+import { type AdminModalContext } from '../types';
+import { type AdminModalKey } from '../data';
+type ModalOpenFn = <K extends AdminModalKey>(modal: K, context?: AdminModalContext<K>) => void;
+type ModalCloseFn = <K extends AdminModalKey>(modal: K) => void;
+type ModalStore = {
+    loading: Ref<boolean>;
+    opened: Ref<AdminModalKey | null>;
+    context: Ref<UnwrapNestedRefs<AdminModalContext>>;
+    onOpen(callback: ModalOpenFn): void;
+    onClose(callback: ModalCloseFn): void;
+    open<K extends AdminModalKey>(modal: K, newContext?: AdminModalContext<K>): void;
+    close(): void;
+};
+export declare const useModalStore: import("pinia").StoreDefinition<"modal", import("pinia")._UnwrapAll<Pick<ModalStore, "context" | "loading" | "opened">>, Pick<ModalStore, never>, Pick<ModalStore, "open" | "close" | "onOpen" | "onClose">>;
+export {};

package/dist/stores/useNotificationStore.d.ts

@@ -0,0 +1,60 @@
+import { type NotificationId, type PdkNotification } from '../types';
+import { NotificationSource } from '../data';
+export declare const useNotificationStore: import("pinia").StoreDefinition<"notifications", import("pinia")._UnwrapAll<Pick<{
+    notifications: import("vue").Ref<{
+        category?: import("..").NotificationCategory | undefined;
+        content?: import("@myparcel-dev/ts-utils").OneOrMore<string> | undefined;
+        dismissible: boolean;
+        id: string | number;
+        tags?: Record<string, string> | undefined;
+        timeout: boolean | number;
+        title?: string | undefined;
+        variant: import("@myparcel-dev/pdk-common").Variant;
+    }[]>;
+    /**
+     * Add a notification to the store.
+     */
+    add(notification: PdkNotification, tags?: object | Record<string, string>): void;
+    /**
+     * Remove one or more notifications from the store by tag or id.
+     */
+    remove(input: NotificationId | NotificationSource): void;
+}, "notifications">>, Pick<{
+    notifications: import("vue").Ref<{
+        category?: import("..").NotificationCategory | undefined;
+        content?: import("@myparcel-dev/ts-utils").OneOrMore<string> | undefined;
+        dismissible: boolean;
+        id: string | number;
+        tags?: Record<string, string> | undefined;
+        timeout: boolean | number;
+        title?: string | undefined;
+        variant: import("@myparcel-dev/pdk-common").Variant;
+    }[]>;
+    /**
+     * Add a notification to the store.
+     */
+    add(notification: PdkNotification, tags?: object | Record<string, string>): void;
+    /**
+     * Remove one or more notifications from the store by tag or id.
+     */
+    remove(input: NotificationId | NotificationSource): void;
+}, never>, Pick<{
+    notifications: import("vue").Ref<{
+        category?: import("..").NotificationCategory | undefined;
+        content?: import("@myparcel-dev/ts-utils").OneOrMore<string> | undefined;
+        dismissible: boolean;
+        id: string | number;
+        tags?: Record<string, string> | undefined;
+        timeout: boolean | number;
+        title?: string | undefined;
+        variant: import("@myparcel-dev/pdk-common").Variant;
+    }[]>;
+    /**
+     * Add a notification to the store.
+     */
+    add(notification: PdkNotification, tags?: object | Record<string, string>): void;
+    /**
+     * Remove one or more notifications from the store by tag or id.
+     */
+    remove(input: NotificationId | NotificationSource): void;
+}, "add" | "remove">>;

package/dist/stores/useQueryStore.d.ts

@@ -0,0 +1,80 @@
+import { type ComputedRef } from 'vue';
+import { type MaybeRef } from '@vueuse/core';
+import { AdminContextKey, BackendEndpoint } from '@myparcel-dev/pdk-common';
+import { type OneOrMore } from '@myparcel-dev/ts-utils';
+import { MutationMode } from '../services';
+import { type PlainModifier } from '../actions';
+import { type RegisterQuery, type ResolvedQuery } from './types';
+export declare const useQueryStore: import("pinia").StoreDefinition<"query", import("pinia")._UnwrapAll<Pick<{
+    get: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => ResolvedQuery<E>;
+    has: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => boolean;
+    register: RegisterQuery;
+    unregister: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => void;
+    registerShipmentQueries: (shipmentIds: MaybeRef<OneOrMore<number>>, orderIds?: MaybeRef<OneOrMore<string>>) => void;
+    /**
+     * Register queries needed to render any order related component.
+     */
+    registerOrderQueries: (orderId?: string | undefined, mode?: MutationMode) => void;
+    registerProductQueries: (productId?: string | undefined) => void;
+    /**
+     * Register context queries. Always includes global and dynamic context.
+     */
+    registerContextQueries: <C extends Exclude<AdminContextKey, AdminContextKey.Global | AdminContextKey.Dynamic>>(...keys: C[]) => void;
+    getQueriesForShipment(id: number): ComputedRef<Record<BackendEndpoint, ResolvedQuery>>;
+    getQueriesForOrder(externalIdentifier: string): ComputedRef<Record<BackendEndpoint, ResolvedQuery>>;
+    registerWebhookQueries: () => {
+        fetchWebhooks: import("@tanstack/vue-query").UseQueryReturnType<import("..").WebhookDefinition[], import("@myparcel-dev/sdk").ApiException>;
+        createWebhooks: import("@tanstack/vue-query").UseMutationReturnType<any, any, any, any>;
+        deleteWebhooks: import("@tanstack/vue-query").UseMutationReturnType<import("..").WebhookDefinition[], import("@myparcel-dev/sdk").ApiException, {
+            hooks: OneOrMore<string>;
+        }, unknown>;
+    };
+}, never>>, Pick<{
+    get: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => ResolvedQuery<E>;
+    has: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => boolean;
+    register: RegisterQuery;
+    unregister: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => void;
+    registerShipmentQueries: (shipmentIds: MaybeRef<OneOrMore<number>>, orderIds?: MaybeRef<OneOrMore<string>>) => void;
+    /**
+     * Register queries needed to render any order related component.
+     */
+    registerOrderQueries: (orderId?: string | undefined, mode?: MutationMode) => void;
+    registerProductQueries: (productId?: string | undefined) => void;
+    /**
+     * Register context queries. Always includes global and dynamic context.
+     */
+    registerContextQueries: <C extends Exclude<AdminContextKey, AdminContextKey.Global | AdminContextKey.Dynamic>>(...keys: C[]) => void;
+    getQueriesForShipment(id: number): ComputedRef<Record<BackendEndpoint, ResolvedQuery>>;
+    getQueriesForOrder(externalIdentifier: string): ComputedRef<Record<BackendEndpoint, ResolvedQuery>>;
+    registerWebhookQueries: () => {
+        fetchWebhooks: import("@tanstack/vue-query").UseQueryReturnType<import("..").WebhookDefinition[], import("@myparcel-dev/sdk").ApiException>;
+        createWebhooks: import("@tanstack/vue-query").UseMutationReturnType<any, any, any, any>;
+        deleteWebhooks: import("@tanstack/vue-query").UseMutationReturnType<import("..").WebhookDefinition[], import("@myparcel-dev/sdk").ApiException, {
+            hooks: OneOrMore<string>;
+        }, unknown>;
+    };
+}, never>, Pick<{
+    get: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => ResolvedQuery<E>;
+    has: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => boolean;
+    register: RegisterQuery;
+    unregister: <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier) => void;
+    registerShipmentQueries: (shipmentIds: MaybeRef<OneOrMore<number>>, orderIds?: MaybeRef<OneOrMore<string>>) => void;
+    /**
+     * Register queries needed to render any order related component.
+     */
+    registerOrderQueries: (orderId?: string | undefined, mode?: MutationMode) => void;
+    registerProductQueries: (productId?: string | undefined) => void;
+    /**
+     * Register context queries. Always includes global and dynamic context.
+     */
+    registerContextQueries: <C extends Exclude<AdminContextKey, AdminContextKey.Global | AdminContextKey.Dynamic>>(...keys: C[]) => void;
+    getQueriesForShipment(id: number): ComputedRef<Record<BackendEndpoint, ResolvedQuery>>;
+    getQueriesForOrder(externalIdentifier: string): ComputedRef<Record<BackendEndpoint, ResolvedQuery>>;
+    registerWebhookQueries: () => {
+        fetchWebhooks: import("@tanstack/vue-query").UseQueryReturnType<import("..").WebhookDefinition[], import("@myparcel-dev/sdk").ApiException>;
+        createWebhooks: import("@tanstack/vue-query").UseMutationReturnType<any, any, any, any>;
+        deleteWebhooks: import("@tanstack/vue-query").UseMutationReturnType<import("..").WebhookDefinition[], import("@myparcel-dev/sdk").ApiException, {
+            hooks: OneOrMore<string>;
+        }, unknown>;
+    };
+}, "get" | "has" | "register" | "unregister" | "registerShipmentQueries" | "registerOrderQueries" | "registerProductQueries" | "registerContextQueries" | "getQueriesForShipment" | "getQueriesForOrder" | "registerWebhookQueries">>;

package/dist/symbols.d.ts

@@ -0,0 +1,5 @@
+import { type InjectionKey } from 'vue';
+import { type AdminInstance } from './types';
+import { type PdkAdmin } from './pdk';
+export declare const INJECT_ADMIN_INSTANCE: InjectionKey<AdminInstance>;
+export declare const INJECT_GLOBAL_PDK_ADMIN: InjectionKey<PdkAdmin>;

package/dist/testing.d.ts

@@ -0,0 +1 @@
+export * from './__tests__';

package/dist/types/actions/actions.types.d.ts

@@ -0,0 +1,31 @@
+import { type BackendEndpoint } from '@myparcel-dev/pdk-common';
+import { type ReverseMap } from '@myparcel-dev/ts-utils';
+import { type AdminAction } from '../../data';
+export type MaybeAdminAction = AdminAction | undefined;
+export type PrintAction = AdminAction.ShipmentsPrint | AdminAction.OrdersPrint;
+export type OrderAction = AdminAction.OrdersEdit | AdminAction.OrdersExport | AdminAction.OrdersExportPrint | AdminAction.OrdersFetch | AdminAction.OrdersPrint | AdminAction.OrdersUpdate;
+export interface AdminActionEndpointMap extends Record<AdminAction, BackendEndpoint> {
+    [AdminAction.AccountDelete]: BackendEndpoint.DeleteAccount;
+    [AdminAction.AccountUpdate]: BackendEndpoint.UpdateAccount;
+    [AdminAction.ContextFetch]: BackendEndpoint.FetchContext;
+    [AdminAction.DownloadLogs]: BackendEndpoint.DownloadLogs;
+    [AdminAction.SwitchToAcceptanceApi]: BackendEndpoint.SwitchToAcceptanceApi;
+    [AdminAction.SwitchToProductionApi]: BackendEndpoint.SwitchToProductionApi;
+    [AdminAction.OrdersEdit]: BackendEndpoint.UpdateOrders;
+    [AdminAction.OrdersExportPrint]: BackendEndpoint.ExportOrders;
+    [AdminAction.OrdersExport]: BackendEndpoint.ExportOrders;
+    [AdminAction.OrdersFetch]: BackendEndpoint.FetchOrders;
+    [AdminAction.OrdersPrint]: BackendEndpoint.PrintOrders;
+    [AdminAction.OrdersUpdate]: BackendEndpoint.UpdateOrders;
+    [AdminAction.PluginSettingsUpdate]: BackendEndpoint.UpdatePluginSettings;
+    [AdminAction.ProductSettingsUpdate]: BackendEndpoint.UpdateProductSettings;
+    [AdminAction.ShipmentsDelete]: BackendEndpoint.DeleteShipments;
+    [AdminAction.ShipmentsExportReturn]: BackendEndpoint.ExportReturn;
+    [AdminAction.ShipmentsFetch]: BackendEndpoint.FetchShipments;
+    [AdminAction.ShipmentsPrint]: BackendEndpoint.PrintShipments;
+    [AdminAction.ShipmentsUpdate]: BackendEndpoint.UpdateShipments;
+    [AdminAction.WebhooksCreate]: BackendEndpoint.CreateWebhooks;
+    [AdminAction.WebhooksDelete]: BackendEndpoint.DeleteWebhooks;
+    [AdminAction.WebhooksFetch]: BackendEndpoint.FetchWebhooks;
+}
+export type EndpointAdminActionMap = ReverseMap<AdminActionEndpointMap>;

package/dist/types/actions/endpoints.types.d.ts

@@ -0,0 +1,9 @@
+import { type BackendEndpoint } from '@myparcel-dev/pdk-common';
+/**
+ * All backend endpoints that are mutations.
+ */
+export type BackendMutationEndpoints = BackendEndpoint.CreateWebhooks | BackendEndpoint.DownloadLogs | BackendEndpoint.SwitchToAcceptanceApi | BackendEndpoint.SwitchToProductionApi | BackendEndpoint.DeleteAccount | BackendEndpoint.DeleteShipments | BackendEndpoint.DeleteWebhooks | BackendEndpoint.ExportOrders | BackendEndpoint.ExportReturn | BackendEndpoint.PrintOrders | BackendEndpoint.PrintShipments | BackendEndpoint.UpdateAccount | BackendEndpoint.UpdateOrders | BackendEndpoint.UpdatePluginSettings | BackendEndpoint.UpdateProductSettings | BackendEndpoint.UpdateShipments;
+/**
+ * All backend endpoints that are queries.
+ */
+export type BackendQueryEndpoints = BackendEndpoint.FetchContext | BackendEndpoint.FetchOrders | BackendEndpoint.FetchProducts | BackendEndpoint.FetchShipments | BackendEndpoint.FetchWebhooks | BackendEndpoint.ProxyCapabilities;

package/dist/types/actions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './actions.types';
+export * from './endpoints.types';
+export * from './parameters.types';
+export * from './response.types';

package/dist/types/actions/parameters.types.d.ts

@@ -0,0 +1,55 @@
+import { type AdminContextKey, type BackendEndpoint, type LabelFormat, type LabelOutput, type LabelPosition } from '@myparcel-dev/pdk-common';
+import { type FormInstance } from '@myparcel-dev/vue-form-builder';
+import { type OneOrMore } from '@myparcel-dev/ts-utils';
+import { type OrderIds, type ShipmentIds } from '../common.types';
+import { type AdminAction } from '../../data';
+import { type AdminActionEndpointMap, type MaybeAdminAction } from './actions.types';
+type LabelParameters = {
+    output?: LabelOutput;
+    format?: LabelFormat;
+    position?: OneOrMore<LabelPosition>;
+};
+type OrderIdParameters = {
+    orderIds?: OrderIds;
+};
+interface ShipmentIdParameters {
+    shipmentIds?: ShipmentIds;
+}
+type FormParameters = {
+    form: FormInstance;
+};
+type OptionalFormParameters = {
+    form?: false | FormInstance;
+};
+type ProductIdParameters = {
+    productIds?: OneOrMore<string>;
+};
+type HooksParameters = {
+    hooks: OneOrMore<string>;
+};
+type ContextParameters = {
+    context?: OneOrMore<AdminContextKey>;
+};
+export interface EndpointMutationInputMap extends Record<BackendEndpoint, object> {
+    [BackendEndpoint.FetchContext]: ContextParameters;
+    [BackendEndpoint.UpdateAccount]: OptionalFormParameters;
+    [BackendEndpoint.ExportOrders]: OrderIdParameters & OptionalFormParameters;
+    [BackendEndpoint.FetchOrders]: OrderIdParameters;
+    [BackendEndpoint.PrintOrders]: OrderIdParameters & LabelParameters & OptionalFormParameters;
+    [BackendEndpoint.UpdateOrders]: OrderIdParameters & FormParameters;
+    [BackendEndpoint.DeleteShipments]: OrderIdParameters & ShipmentIdParameters;
+    [BackendEndpoint.ExportReturn]: OrderIdParameters & ShipmentIdParameters;
+    [BackendEndpoint.FetchShipments]: OrderIdParameters & ShipmentIdParameters;
+    [BackendEndpoint.UpdateShipments]: OrderIdParameters & ShipmentIdParameters;
+    [BackendEndpoint.PrintShipments]: OrderIdParameters & ShipmentIdParameters & OptionalFormParameters & LabelParameters;
+    [BackendEndpoint.FetchProducts]: ProductIdParameters;
+    [BackendEndpoint.UpdatePluginSettings]: FormParameters;
+    [BackendEndpoint.UpdateProductSettings]: ProductIdParameters & FormParameters;
+    [BackendEndpoint.CreateWebhooks]: HooksParameters;
+    [BackendEndpoint.DeleteWebhooks]: HooksParameters;
+    [BackendEndpoint.FetchWebhooks]: never;
+}
+export type ActionInput<E extends BackendEndpoint> = EndpointMutationInputMap[E];
+export type ActionParameters<A extends string | MaybeAdminAction> = A extends AdminAction ? ActionInput<AdminActionEndpointMap[A]> : object;
+export type MaybeActionParameters<A extends MaybeAdminAction> = ActionParameters<A> | void;
+export {};

package/dist/types/actions/response.types.d.ts

@@ -0,0 +1,7 @@
+import { type BackendEndpoint, type PdkEndpointResponse } from '@myparcel-dev/pdk-common';
+import { type BackendEndpointDefinition } from '../sdk.types';
+import { type AdminAction } from '../../data';
+import { type AdminActionEndpointMap, type MaybeAdminAction } from './actions.types';
+export type BackendEndpointResponse<E extends BackendEndpoint> = PdkEndpointResponse<E, BackendEndpointDefinition>;
+export type ActionResponse<A extends MaybeAdminAction> = A extends AdminAction ? BackendEndpointResponse<AdminActionEndpointMap[A]> : void;
+export type MaybeActionResponse<A extends MaybeAdminAction> = ActionResponse<A> | void;

package/dist/types/actions.types.d.ts

@@ -0,0 +1,45 @@
+import { type MaybeRef } from '@vueuse/core';
+import { type Variant } from '@myparcel-dev/pdk-common';
+import { type OneOrMore, type PromiseOr } from '@myparcel-dev/ts-utils';
+import { type AdminAction, type AdminIcon } from '../data';
+import { type ActionContext, type ActionContextWithResponse, type QueryHandler } from '../actions';
+import { type Translation } from './language.types';
+import { type ActionParameters, type ActionResponse, type AdminActionEndpointMap, type MaybeAdminAction } from './actions';
+interface BaseActionDefinition {
+    disabled?: MaybeRef<boolean>;
+    icon?: AdminIcon;
+    label?: Translation;
+    notifications?: OneOrMore<Variant>;
+    standalone?: boolean;
+    variant?: MaybeRef<Variant | undefined>;
+    afterHandle?(...args: unknown[]): PromiseOr<unknown>;
+    beforeHandle?(...args: unknown[]): PromiseOr<unknown>;
+    handler(...args: unknown[]): PromiseOr<unknown>;
+}
+export interface NamedActionDefinition<A extends AdminAction = AdminAction> extends BaseActionDefinition {
+    name: A;
+    afterHandle?(context: ActionContextWithResponse<A>): PromiseOr<ActionResponse<A>>;
+    beforeHandle?(context: ActionContext<A>): PromiseOr<ActionParameters<A>>;
+    handler: QueryHandler<AdminActionEndpointMap[A]>;
+}
+export interface GenericActionDefinition extends BaseActionDefinition {
+    name?: never;
+    id: string;
+    afterHandle?(context: ActionContextWithResponse): PromiseOr<void>;
+    beforeHandle?(context: ActionContext): PromiseOr<void>;
+    handler(context: ActionContext): PromiseOr<void>;
+}
+export type AnyActionDefinition<A extends MaybeAdminAction = MaybeAdminAction> = A extends AdminAction ? NamedActionDefinition<A> : GenericActionDefinition;
+export type ActionDefinition<A extends MaybeAdminAction = MaybeAdminAction> = AnyActionDefinition<A> & {
+    id: string;
+    parameters?: ActionParameters<A>;
+};
+/**
+ * The final action type that can be executed.
+ */
+export type ResolvedAction = BaseActionDefinition & {
+    id: string;
+    standalone?: boolean;
+    handler(parameters?: ActionParameters<AdminAction> | Record<string, unknown>): PromiseOr<void>;
+};
+export {};

package/dist/types/admin.types.d.ts

@@ -0,0 +1,26 @@
+import { type Component } from 'vue';
+import { type PdkLogger } from '../services';
+import { type ADMIN_COMPONENT_PREFIX, type AdminComponent, type AdminView, type optionalAdminActionContainerComponentNames, type optionalAdminComponentNames, type optionalAdminPlainWrapperComponentNames, type requiredAdminComponentNames } from '../data';
+import { type AdminContextObject, type AdminInstanceContext } from './context.types';
+import { type AdminConfiguration } from './configuration.types';
+export type RequiredAdminComponentName = (typeof requiredAdminComponentNames)[number];
+export type OptionalAdminComponentName = (typeof optionalAdminComponentNames)[number] | (typeof optionalAdminPlainWrapperComponentNames)[number] | (typeof optionalAdminActionContainerComponentNames)[number];
+export type PrefixedAdminComponent<A extends AdminComponent = AdminComponent> = `${typeof ADMIN_COMPONENT_PREFIX}${A}`;
+export type AdminComponentMap = Record<RequiredAdminComponentName, Component> & Partial<Record<OptionalAdminComponentName, Component>>;
+/**
+ * Prefer using AdminComponentMap instead to reduce bundle size.
+ */
+export type PrefixedAdminComponentMap = Record<PrefixedAdminComponent<RequiredAdminComponentName>, Component> & Partial<Record<PrefixedAdminComponent<OptionalAdminComponentName>, Component>>;
+export type ComponentImportFunction = () => Promise<{
+    default: Component;
+}>;
+export interface AdminAppConfig {
+    appName: string;
+    config: AdminConfiguration;
+    context: AdminContextObject;
+    logger: PdkLogger;
+    view?: AdminView;
+}
+export interface AdminInstance extends Omit<AdminAppConfig, 'context'> {
+    context: Partial<AdminInstanceContext>;
+}