@devite/shopware-client 1.0.1 → 1.1.0

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

@@ -0,0 +1,89 @@
+import { StateMachine } from "#types/api/admin/stateMachine/StateMachine";
+import { StateMachineState } from "#types/api/admin/stateMachine/StateMachineState";
+import { StateMachineTransition } from "#types/api/admin/stateMachine/StateMachineTransition";
+import { Criteria } from "#types/api/global/query/Criteria";
+import { Aggregation } from "#types/api/global/aggregation/Aggregation";
+/** State Machines **/
+export interface StateMachineListResponse {
+    total?: number;
+    data?: Array<StateMachine>;
+}
+export type StateMachineCreateRequest = StateMachine;
+export type StateMachineCreateResponse = {
+    data: StateMachine;
+};
+export type StateMachineListSearchRequest = Criteria;
+export interface StateMachineListSearchResponse {
+    total?: number;
+    data?: Array<StateMachine>;
+}
+export interface StateMachineSingleResponse {
+    data: StateMachine;
+}
+export type StateMachineUpdateRequest = StateMachine;
+export type StateMachineUpdateResponse = {
+    data: StateMachine;
+};
+export interface StateMachineAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface StateMachineAggregationResponse {
+    total?: number;
+    data?: Array<StateMachine>;
+}
+/** States **/
+export interface StateListResponse {
+    total?: number;
+    data?: Array<StateMachineState>;
+}
+export type StateCreateRequest = StateMachineState;
+export type StateCreateResponse = {
+    data: StateMachineState;
+};
+export type StateListSearchRequest = Criteria;
+export interface StateListSearchResponse {
+    total?: number;
+    data?: Array<StateMachineState>;
+}
+export interface StateSingleResponse {
+    data: StateMachineState;
+}
+export type StateUpdateRequest = StateMachineState;
+export type StateUpdateResponse = {
+    data: StateMachineState;
+};
+export interface StateAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface StateAggregationResponse {
+    total?: number;
+    data?: Array<StateMachineState>;
+}
+/** Transitions **/
+export interface TransitionListResponse {
+    total?: number;
+    data?: Array<StateMachineTransition>;
+}
+export type TransitionCreateRequest = StateMachineTransition;
+export type TransitionCreateResponse = {
+    data: StateMachineTransition;
+};
+export type TransitionListSearchRequest = Criteria;
+export interface TransitionListSearchResponse {
+    total?: number;
+    data?: Array<StateMachineTransition>;
+}
+export interface TransitionSingleResponse {
+    data: StateMachineTransition;
+}
+export type TransitionUpdateRequest = StateMachineTransition;
+export type TransitionUpdateResponse = {
+    data: StateMachineTransition;
+};
+export interface TransitionAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface TransitionAggregationResponse {
+    total?: number;
+    data?: Array<StateMachineTransition>;
+}

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

@@ -0,0 +1,185 @@
+import { LogEntry } from "#types/api/admin/LogEntry";
+import { Notification } from "#types/api/admin/Notification";
+import { SystemConfig } from "#types/api/admin/SystemConfig";
+import { ScheduledTask } from "#types/api/admin/ScheduledTask";
+import { Criteria } from "#types/api/global/query/Criteria";
+import { Aggregation } from "#types/api/global/aggregation/Aggregation";
+/** Info & Health **/
+export type BusinessEventsResponse = Array<{
+    name?: string;
+    class?: string;
+    data?: object;
+    aware?: Array<string>;
+    extensions?: Array<string>;
+}>;
+export interface ShopwareVersionResponse {
+    version?: string;
+}
+export interface HealthReportResponse {
+    checks?: Array<{
+        name?: string;
+        healthy?: boolean;
+        status?: string;
+        message?: string;
+    }>;
+}
+export type FlowBuilderActionsResponse = Array<{
+    name?: string;
+    requirements?: Array<string>;
+    extensions?: Array<string>;
+}>;
+export interface ApiConfigResponse {
+    version?: string;
+    versionRevision?: string;
+    adminWorker?: {
+        enableAdminWorker?: boolean;
+        transports?: Array<string>;
+    };
+    bundles?: Record<string, {
+        css?: Array<string>;
+        js?: Array<string>;
+    }>;
+    settings?: {
+        enableUrlFeature?: boolean;
+    };
+}
+/** Operations **/
+export interface IndexRequest {
+    skip?: Array<string>;
+}
+export interface IndexIterationRequest {
+    offset?: number;
+}
+export interface IndexIterationResponse {
+    finish?: boolean;
+    offset?: number;
+}
+export interface CacheInfoResponse {
+    environment?: string;
+    httpCache?: boolean;
+    cacheAdapter?: string;
+}
+export interface MessageQueueConsumptionRequest {
+    receiver: string;
+}
+export interface MessageQueueConsumptionResponse {
+    handledMessages?: number;
+}
+export interface ScheduledTaskRunResponse {
+    message?: string;
+}
+export interface ScheduledTaskMinIntervalResponse {
+    minRunInterval?: string;
+}
+/** Log Entries **/
+export interface LogEntryListResponse {
+    total?: number;
+    data?: Array<LogEntry>;
+}
+export type LogEntryCreateRequest = LogEntry;
+export type LogEntryCreateResponse = {
+    data: LogEntry;
+};
+export type LogEntryListSearchRequest = Criteria;
+export interface LogEntryListSearchResponse {
+    total?: number;
+    data?: Array<LogEntry>;
+}
+export interface LogEntrySingleResponse {
+    data: LogEntry;
+}
+export type LogEntryUpdateRequest = LogEntry;
+export type LogEntryUpdateResponse = {
+    data: LogEntry;
+};
+export interface LogEntryAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface LogEntryAggregationResponse {
+    total?: number;
+    data?: Array<LogEntry>;
+}
+/** Notifications **/
+export interface NotificationListResponse {
+    total?: number;
+    data?: Array<Notification>;
+}
+export type NotificationCreateRequest = Notification;
+export type NotificationCreateResponse = {
+    data: Notification;
+};
+export type NotificationListSearchRequest = Criteria;
+export interface NotificationListSearchResponse {
+    total?: number;
+    data?: Array<Notification>;
+}
+export interface NotificationSingleResponse {
+    data: Notification;
+}
+export type NotificationUpdateRequest = Notification;
+export type NotificationUpdateResponse = {
+    data: Notification;
+};
+export interface NotificationAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface NotificationAggregationResponse {
+    total?: number;
+    data?: Array<Notification>;
+}
+/** Config Entries **/
+export interface ConfigEntryListResponse {
+    total?: number;
+    data?: Array<SystemConfig>;
+}
+export type ConfigEntryCreateRequest = SystemConfig;
+export type ConfigEntryCreateResponse = {
+    data: SystemConfig;
+};
+export type ConfigEntryListSearchRequest = Criteria;
+export interface ConfigEntryListSearchResponse {
+    total?: number;
+    data?: Array<SystemConfig>;
+}
+export interface ConfigEntrySingleResponse {
+    data: SystemConfig;
+}
+export type ConfigEntryUpdateRequest = SystemConfig;
+export type ConfigEntryUpdateResponse = {
+    data: SystemConfig;
+};
+export interface ConfigEntryAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface ConfigEntryAggregationResponse {
+    total?: number;
+    data?: Array<SystemConfig>;
+}
+/** Scheduled Tasks **/
+export interface ScheduledTaskListResponse {
+    total?: number;
+    data?: Array<ScheduledTask>;
+}
+export type ScheduledTaskCreateRequest = ScheduledTask;
+export type ScheduledTaskCreateResponse = {
+    data: ScheduledTask;
+};
+export type ScheduledTaskListSearchRequest = Criteria;
+export interface ScheduledTaskListSearchResponse {
+    total?: number;
+    data?: Array<ScheduledTask>;
+}
+export interface ScheduledTaskSingleResponse {
+    data: ScheduledTask;
+}
+export type ScheduledTaskUpdateRequest = ScheduledTask;
+export type ScheduledTaskUpdateResponse = {
+    data: ScheduledTask;
+};
+export interface ScheduledTaskAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface ScheduledTaskAggregationResponse {
+    total?: number;
+    data?: Array<ScheduledTask>;
+}

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

@@ -0,0 +1,30 @@
+import { Tag } from "#types/api/admin/Tag";
+import { Criteria } from "#types/api/global/query/Criteria";
+import { Aggregation } from "#types/api/global/aggregation/Aggregation";
+export interface TagListResponse {
+    total?: number;
+    data?: Array<Tag>;
+}
+export type TagCreateRequest = Tag;
+export type TagCreateResponse = {
+    data: Tag;
+};
+export type TagListSearchRequest = Criteria;
+export interface TagListSearchResponse {
+    total?: number;
+    data?: Array<Tag>;
+}
+export interface TagSingleResponse {
+    data: Tag;
+}
+export type TagUpdateRequest = Tag;
+export type TagUpdateResponse = {
+    data: Tag;
+};
+export interface TagAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface TagAggregationResponse {
+    total?: number;
+    data?: Array<Tag>;
+}

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

@@ -0,0 +1,118 @@
+import { Tax } from "#types/api/admin/tax/Tax";
+import { TaxProvider } from "#types/api/admin/tax/TaxProvider";
+import { TaxRule } from "#types/api/admin/tax/rule/TaxRule";
+import { TaxRuleType } from "#types/api/admin/tax/rule/TaxRuleType";
+import { Criteria } from "#types/api/global/query/Criteria";
+import { Aggregation } from "#types/api/global/aggregation/Aggregation";
+/** Taxes **/
+export interface TaxListResponse {
+    total?: number;
+    data?: Array<Tax>;
+}
+export type TaxCreateRequest = Tax;
+export type TaxCreateResponse = {
+    data: Tax;
+};
+export type TaxListSearchRequest = Criteria;
+export interface TaxListSearchResponse {
+    total?: number;
+    data?: Array<Tax>;
+}
+export interface TaxSingleResponse {
+    data: Tax;
+}
+export type TaxUpdateRequest = Tax;
+export type TaxUpdateResponse = {
+    data: Tax;
+};
+export interface TaxAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface TaxAggregationResponse {
+    total?: number;
+    data?: Array<Tax>;
+}
+/** Providers **/
+export interface ProviderListResponse {
+    total?: number;
+    data?: Array<TaxProvider>;
+}
+export type ProviderCreateRequest = TaxProvider;
+export type ProviderCreateResponse = {
+    data: TaxProvider;
+};
+export type ProviderListSearchRequest = Criteria;
+export interface ProviderListSearchResponse {
+    total?: number;
+    data?: Array<TaxProvider>;
+}
+export interface ProviderSingleResponse {
+    data: TaxProvider;
+}
+export type ProviderUpdateRequest = TaxProvider;
+export type ProviderUpdateResponse = {
+    data: TaxProvider;
+};
+export interface ProviderAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface ProviderAggregationResponse {
+    total?: number;
+    data?: Array<TaxProvider>;
+}
+/** Rules **/
+export interface RuleListResponse {
+    total?: number;
+    data?: Array<TaxRule>;
+}
+export type RuleCreateRequest = TaxRule;
+export type RuleCreateResponse = {
+    data: TaxRule;
+};
+export type RuleListSearchRequest = Criteria;
+export interface RuleListSearchResponse {
+    total?: number;
+    data?: Array<TaxRule>;
+}
+export interface RuleSingleResponse {
+    data: TaxRule;
+}
+export type RuleUpdateRequest = TaxRule;
+export type RuleUpdateResponse = {
+    data: TaxRule;
+};
+export interface RuleAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface RuleAggregationResponse {
+    total?: number;
+    data?: Array<TaxRule>;
+}
+/** Rule Types **/
+export interface RuleTypeListResponse {
+    total?: number;
+    data?: Array<TaxRuleType>;
+}
+export type RuleTypeCreateRequest = TaxRuleType;
+export type RuleTypeCreateResponse = {
+    data: TaxRuleType;
+};
+export type RuleTypeListSearchRequest = Criteria;
+export interface RuleTypeListSearchResponse {
+    total?: number;
+    data?: Array<TaxRuleType>;
+}
+export interface RuleTypeSingleResponse {
+    data: TaxRuleType;
+}
+export type RuleTypeUpdateRequest = TaxRuleType;
+export type RuleTypeUpdateResponse = {
+    data: TaxRuleType;
+};
+export interface RuleTypeAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface RuleTypeAggregationResponse {
+    total?: number;
+    data?: Array<TaxRuleType>;
+}

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

@@ -0,0 +1,30 @@
+import { Unit } from "#types/api/admin/Unit";
+import { Criteria } from "#types/api/global/query/Criteria";
+import { Aggregation } from "#types/api/global/aggregation/Aggregation";
+export interface UnitListResponse {
+    total?: number;
+    data?: Array<Unit>;
+}
+export type UnitCreateRequest = Unit;
+export type UnitCreateResponse = {
+    data: Unit;
+};
+export type UnitListSearchRequest = Criteria;
+export interface UnitListSearchResponse {
+    total?: number;
+    data?: Array<Unit>;
+}
+export interface UnitSingleResponse {
+    data: Unit;
+}
+export type UnitUpdateRequest = Unit;
+export type UnitUpdateResponse = {
+    data: Unit;
+};
+export interface UnitAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface UnitAggregationResponse {
+    total?: number;
+    data?: Array<Unit>;
+}

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

@@ -0,0 +1,118 @@
+import { User } from "#types/api/admin/user/User";
+import { UserAccessKey } from "#types/api/admin/user/UserAccessKey";
+import { UserConfig } from "#types/api/admin/user/UserConfig";
+import { UserRecovery } from "#types/api/admin/user/UserRecovery";
+import { Criteria } from "#types/api/global/query/Criteria";
+import { Aggregation } from "#types/api/global/aggregation/Aggregation";
+/** Users **/
+export interface UserListResponse {
+    total?: number;
+    data?: Array<User>;
+}
+export type UserCreateRequest = User;
+export type UserCreateResponse = {
+    data: User;
+};
+export type UserListSearchRequest = Criteria;
+export interface UserListSearchResponse {
+    total?: number;
+    data?: Array<User>;
+}
+export interface UserSingleResponse {
+    data: User;
+}
+export type UserUpdateRequest = User;
+export type UserUpdateResponse = {
+    data: User;
+};
+export interface UserAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface UserAggregationResponse {
+    total?: number;
+    data?: Array<User>;
+}
+/** Access Keys **/
+export interface AccessKeyListResponse {
+    total?: number;
+    data?: Array<UserAccessKey>;
+}
+export type AccessKeyCreateRequest = UserAccessKey;
+export type AccessKeyCreateResponse = {
+    data: UserAccessKey;
+};
+export type AccessKeyListSearchRequest = Criteria;
+export interface AccessKeyListSearchResponse {
+    total?: number;
+    data?: Array<UserAccessKey>;
+}
+export interface AccessKeySingleResponse {
+    data: UserAccessKey;
+}
+export type AccessKeyUpdateRequest = UserAccessKey;
+export type AccessKeyUpdateResponse = {
+    data: UserAccessKey;
+};
+export interface AccessKeyAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface AccessKeyAggregationResponse {
+    total?: number;
+    data?: Array<UserAccessKey>;
+}
+/** Configs **/
+export interface ConfigListResponse {
+    total?: number;
+    data?: Array<UserConfig>;
+}
+export type ConfigCreateRequest = UserConfig;
+export type ConfigCreateResponse = {
+    data: UserConfig;
+};
+export type ConfigListSearchRequest = Criteria;
+export interface ConfigListSearchResponse {
+    total?: number;
+    data?: Array<UserConfig>;
+}
+export interface ConfigSingleResponse {
+    data: UserConfig;
+}
+export type ConfigUpdateRequest = UserConfig;
+export type ConfigUpdateResponse = {
+    data: UserConfig;
+};
+export interface ConfigAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface ConfigAggregationResponse {
+    total?: number;
+    data?: Array<UserConfig>;
+}
+/** Recoveries **/
+export interface RecoveryListResponse {
+    total?: number;
+    data?: Array<UserRecovery>;
+}
+export type RecoveryCreateRequest = UserRecovery;
+export type RecoveryCreateResponse = {
+    data: UserRecovery;
+};
+export type RecoveryListSearchRequest = Criteria;
+export interface RecoveryListSearchResponse {
+    total?: number;
+    data?: Array<UserRecovery>;
+}
+export interface RecoverySingleResponse {
+    data: UserRecovery;
+}
+export type RecoveryUpdateRequest = UserRecovery;
+export type RecoveryUpdateResponse = {
+    data: UserRecovery;
+};
+export interface RecoveryAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface RecoveryAggregationResponse {
+    total?: number;
+    data?: Array<UserRecovery>;
+}

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

@@ -0,0 +1,60 @@
+import { Webhook } from "#types/api/admin/webhook/Webhook";
+import { WebhookEventLog } from "#types/api/admin/webhook/WebhookEventLog";
+import { Criteria } from "#types/api/global/query/Criteria";
+import { Aggregation } from "#types/api/global/aggregation/Aggregation";
+/** Webhooks **/
+export interface WebhookListResponse {
+    total?: number;
+    data?: Array<Webhook>;
+}
+export type WebhookCreateRequest = Webhook;
+export type WebhookCreateResponse = {
+    data: Webhook;
+};
+export type WebhookListSearchRequest = Criteria;
+export interface WebhookListSearchResponse {
+    total?: number;
+    data?: Array<Webhook>;
+}
+export interface WebhookSingleResponse {
+    data: Webhook;
+}
+export type WebhookUpdateRequest = Webhook;
+export type WebhookUpdateResponse = {
+    data: Webhook;
+};
+export interface WebhookAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface WebhookAggregationResponse {
+    total?: number;
+    data?: Array<Webhook>;
+}
+/** Event Logs **/
+export interface EventLogListResponse {
+    total?: number;
+    data?: Array<WebhookEventLog>;
+}
+export type EventLogCreateRequest = WebhookEventLog;
+export type EventLogCreateResponse = {
+    data: WebhookEventLog;
+};
+export type EventLogListSearchRequest = Criteria;
+export interface EventLogListSearchResponse {
+    total?: number;
+    data?: Array<WebhookEventLog>;
+}
+export interface EventLogSingleResponse {
+    data: WebhookEventLog;
+}
+export type EventLogUpdateRequest = WebhookEventLog;
+export type EventLogUpdateResponse = {
+    data: WebhookEventLog;
+};
+export interface EventLogAggregationRequest {
+    aggregations: Array<Aggregation>;
+}
+export interface EventLogAggregationResponse {
+    total?: number;
+    data?: Array<WebhookEventLog>;
+}

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

@@ -0,0 +1 @@
+export * from "./AppClient";