@salesforce/lds-adapters-industries-scheduler 0.131.0

package/dist/es/es2018/types/src/generated/types/WaitlistOutputRepresentation.d.ts

@@ -0,0 +1,30 @@
+import { WaitlistListResult as WaitlistListResult_WaitlistListResult } from './WaitlistListResult';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "488cdb7cdd4ebfeca769103b193e0d94";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistOutputRepresentation, existing: WaitlistOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistOutputRepresentationNormalized, incoming: WaitlistOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: WaitlistOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of Waitlist (List) Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistOutputRepresentationNormalized {
+    /** Waitlist result */
+    result: WaitlistListResult_WaitlistListResult;
+}
+/**
+ * Output representation of Waitlist (List) Representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistOutputRepresentation {
+    result: WaitlistListResult_WaitlistListResult;
+}

package/dist/es/es2018/types/src/generated/types/WaitlistParticipantParticipant.d.ts

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "d2fff3a212d202fe7105cf673cefd052";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistParticipantParticipant, existing: WaitlistParticipantParticipantNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistParticipantParticipantNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistParticipantParticipantNormalized, incoming: WaitlistParticipantParticipantNormalized): boolean;
+export declare function deepFreeze(input: WaitlistParticipantParticipant): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistParticipantParticipant, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Waitlist Participant Participant
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistParticipantParticipantNormalized {
+    /** Id */
+    id?: string;
+    /** Name */
+    name?: string;
+}
+/**
+ * Waitlist Participant Participant
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistParticipantParticipant {
+    id?: string;
+    name?: string;
+}

package/dist/es/es2018/types/src/generated/types/WaitlistParticipantResult.d.ts

@@ -0,0 +1,45 @@
+import { WaitlistParticipantParticipant as WaitlistParticipantParticipant_WaitlistParticipantParticipant } from './WaitlistParticipantParticipant';
+import { WaitlistServiceResource as WaitlistServiceResource_WaitlistServiceResource } from './WaitlistServiceResource';
+import { WaitlistWorkTypeGroup as WaitlistWorkTypeGroup_WaitlistWorkTypeGroup } from './WaitlistWorkTypeGroup';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "ef7d2716f1638629b639db123a6686a6";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistParticipantResult, existing: WaitlistParticipantResultNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistParticipantResultNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistParticipantResultNormalized, incoming: WaitlistParticipantResultNormalized): boolean;
+export declare function deepFreeze(input: WaitlistParticipantResult): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistParticipantResult, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Waitlist Participant Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistParticipantResultNormalized {
+    /** Waitlist Participant */
+    participant?: WaitlistParticipantParticipant_WaitlistParticipantParticipant;
+    /** Waitlist Participant Identifier */
+    participantIdentifier?: string;
+    /** Service Appointment ID */
+    serviceAppointmentId: string;
+    serviceResource?: WaitlistServiceResource_WaitlistServiceResource;
+    /** Waitlist Participant ID */
+    waitlistParticipantId?: string;
+    workTypeGroup?: WaitlistWorkTypeGroup_WaitlistWorkTypeGroup;
+}
+/**
+ * Waitlist Participant Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistParticipantResult {
+    participant?: WaitlistParticipantParticipant_WaitlistParticipantParticipant;
+    participantIdentifier?: string;
+    serviceAppointmentId: string;
+    serviceResource?: WaitlistServiceResource_WaitlistServiceResource;
+    waitlistParticipantId?: string;
+    workTypeGroup?: WaitlistWorkTypeGroup_WaitlistWorkTypeGroup;
+}

package/dist/es/es2018/types/src/generated/types/WaitlistRelationshipsOutputRepresentation.d.ts

@@ -0,0 +1,29 @@
+import { WaitlistRelationshipsResult as WaitlistRelationshipsResult_WaitlistRelationshipsResult } from './WaitlistRelationshipsResult';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "29fcdb20c868bda3a922585f54290d7c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistRelationshipsOutputRepresentation, existing: WaitlistRelationshipsOutputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistRelationshipsOutputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistRelationshipsOutputRepresentationNormalized, incoming: WaitlistRelationshipsOutputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: WaitlistRelationshipsOutputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistRelationshipsOutputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Output representation of Waitlist Relationships
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistRelationshipsOutputRepresentationNormalized {
+    result: WaitlistRelationshipsResult_WaitlistRelationshipsResult;
+}
+/**
+ * Output representation of Waitlist Relationships
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistRelationshipsOutputRepresentation {
+    result: WaitlistRelationshipsResult_WaitlistRelationshipsResult;
+}

package/dist/es/es2018/types/src/generated/types/WaitlistRelationshipsResult.d.ts

@@ -0,0 +1,34 @@
+import { WaitlistServiceResource as WaitlistServiceResource_WaitlistServiceResource } from './WaitlistServiceResource';
+import { WaitlistWorkType as WaitlistWorkType_WaitlistWorkType } from './WaitlistWorkType';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "40ccf5da52ce8c2d8c65c70c1e2b98c1";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistRelationshipsResult, existing: WaitlistRelationshipsResultNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistRelationshipsResultNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistRelationshipsResultNormalized, incoming: WaitlistRelationshipsResultNormalized): boolean;
+export declare function deepFreeze(input: WaitlistRelationshipsResult): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistRelationshipsResult, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Waitlist Relationships Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistRelationshipsResultNormalized {
+    /** Service Resources */
+    serviceResources?: Array<WaitlistServiceResource_WaitlistServiceResource>;
+    /** Work Types */
+    workTypes?: Array<WaitlistWorkType_WaitlistWorkType>;
+}
+/**
+ * Waitlist Relationships Result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistRelationshipsResult {
+    serviceResources?: Array<WaitlistServiceResource_WaitlistServiceResource>;
+    workTypes?: Array<WaitlistWorkType_WaitlistWorkType>;
+}

package/dist/es/es2018/types/src/generated/types/WaitlistResult.d.ts

@@ -0,0 +1,54 @@
+import { WaitlistServiceResource as WaitlistServiceResource_WaitlistServiceResource } from './WaitlistServiceResource';
+import { WaitlistAnalytics as WaitlistAnalytics_WaitlistAnalytics } from './WaitlistAnalytics';
+import { WaitlistParticipantResult as WaitlistParticipantResult_WaitlistParticipantResult } from './WaitlistParticipantResult';
+import { WaitlistWorkTypeGroup as WaitlistWorkTypeGroup_WaitlistWorkTypeGroup } from './WaitlistWorkTypeGroup';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "fc44ef5c2e6ac55948cb0cd80e157f89";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistResult, existing: WaitlistResultNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistResultNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistResultNormalized, incoming: WaitlistResultNormalized): boolean;
+export declare function deepFreeze(input: WaitlistResult): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistResult, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Waitlist result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistResultNormalized {
+    /** Description */
+    description?: string;
+    /** Active */
+    isActive?: boolean;
+    /** Waitlist Name */
+    name?: string;
+    /** Service Resources */
+    serviceResources?: Array<WaitlistServiceResource_WaitlistServiceResource>;
+    /** Waitlist Analytics */
+    waitlistAnalytics?: WaitlistAnalytics_WaitlistAnalytics;
+    /** Waitlist ID */
+    waitlistId?: string;
+    /** Waitlist Participants */
+    waitlistParticipants?: Array<WaitlistParticipantResult_WaitlistParticipantResult>;
+    /** Work Type Groups */
+    workTypeGroups?: Array<WaitlistWorkTypeGroup_WaitlistWorkTypeGroup>;
+}
+/**
+ * Waitlist result
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistResult {
+    description?: string;
+    isActive?: boolean;
+    name?: string;
+    serviceResources?: Array<WaitlistServiceResource_WaitlistServiceResource>;
+    waitlistAnalytics?: WaitlistAnalytics_WaitlistAnalytics;
+    waitlistId?: string;
+    waitlistParticipants?: Array<WaitlistParticipantResult_WaitlistParticipantResult>;
+    workTypeGroups?: Array<WaitlistWorkTypeGroup_WaitlistWorkTypeGroup>;
+}

package/dist/es/es2018/types/src/generated/types/WaitlistServiceResource.d.ts

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "2ef071c700b84cba91e63e981e2eede7";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistServiceResource, existing: WaitlistServiceResourceNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistServiceResourceNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistServiceResourceNormalized, incoming: WaitlistServiceResourceNormalized): boolean;
+export declare function deepFreeze(input: WaitlistServiceResource): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistServiceResource, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Waitlist Service Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistServiceResourceNormalized {
+    /** Id */
+    id?: string;
+    /** Name */
+    name?: string;
+}
+/**
+ * Waitlist Service Resource
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistServiceResource {
+    id?: string;
+    name?: string;
+}

package/dist/es/es2018/types/src/generated/types/WaitlistServiceResourceWithWorkTypes.d.ts

@@ -0,0 +1,38 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "235368820a5a56f542c7f4ecb4e2141c";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistServiceResourceWithWorkTypes, existing: WaitlistServiceResourceWithWorkTypesNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistServiceResourceWithWorkTypesNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistServiceResourceWithWorkTypesNormalized, incoming: WaitlistServiceResourceWithWorkTypesNormalized): boolean;
+export declare function deepFreeze(input: WaitlistServiceResourceWithWorkTypes): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistServiceResourceWithWorkTypes, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Waitlist Service Resource With Work Types
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistServiceResourceWithWorkTypesNormalized {
+    /** Id */
+    id: string;
+    /** serviceResourceId */
+    serviceResourceId: string;
+    /** waitlistId */
+    waitlistId: string;
+    /** workTypeIds */
+    workTypeIds: Array<string>;
+}
+/**
+ * Waitlist Service Resource With Work Types
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistServiceResourceWithWorkTypes {
+    id: string;
+    serviceResourceId: string;
+    waitlistId: string;
+    workTypeIds: Array<string>;
+}

package/dist/es/es2018/types/src/generated/types/WaitlistWorkType.d.ts

@@ -0,0 +1,39 @@
+import { WaitlistResult as WaitlistResult_WaitlistResult } from './WaitlistResult';
+import { WaitlistWorkTypeGroup as WaitlistWorkTypeGroup_WaitlistWorkTypeGroup } from './WaitlistWorkTypeGroup';
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "2a2aa9be1b0b3154e15f808f918ba516";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistWorkType, existing: WaitlistWorkTypeNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistWorkTypeNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistWorkTypeNormalized, incoming: WaitlistWorkTypeNormalized): boolean;
+export declare function deepFreeze(input: WaitlistWorkType): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistWorkType, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Waitlist Work Type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistWorkTypeNormalized {
+    /** Id */
+    id?: string;
+    /** Name */
+    name?: string;
+    /** Waitlist */
+    waitlist?: WaitlistResult_WaitlistResult;
+    workTypeGroup?: WaitlistWorkTypeGroup_WaitlistWorkTypeGroup;
+}
+/**
+ * Waitlist Work Type
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistWorkType {
+    id?: string;
+    name?: string;
+    waitlist?: WaitlistResult_WaitlistResult;
+    workTypeGroup?: WaitlistWorkTypeGroup_WaitlistWorkTypeGroup;
+}

package/dist/es/es2018/types/src/generated/types/WaitlistWorkTypeGroup.d.ts

@@ -0,0 +1,32 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "9d573b064500fae0b4205231dae5af50";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WaitlistWorkTypeGroup, existing: WaitlistWorkTypeGroupNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WaitlistWorkTypeGroupNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WaitlistWorkTypeGroupNormalized, incoming: WaitlistWorkTypeGroupNormalized): boolean;
+export declare function deepFreeze(input: WaitlistWorkTypeGroup): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WaitlistWorkTypeGroup, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Waitlist Work Type Group
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistWorkTypeGroupNormalized {
+    /** Id */
+    id?: string;
+    /** Name */
+    name?: string;
+}
+/**
+ * Waitlist Work Type Group
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WaitlistWorkTypeGroup {
+    id?: string;
+    name?: string;
+}

package/dist/es/es2018/types/src/generated/types/WorkTypeInputRepresentation.d.ts

@@ -0,0 +1,53 @@
+import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
+export declare const VERSION = "4edf407fce3a3c5f105871a21950b788";
+export declare function validate(obj: any, path?: string): TypeError | null;
+export declare const RepresentationType: string;
+export declare function normalize(input: WorkTypeInputRepresentation, existing: WorkTypeInputRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): WorkTypeInputRepresentationNormalized;
+export declare const select: () => $64$luvio_engine_FragmentSelection;
+export declare function equals(existing: WorkTypeInputRepresentationNormalized, incoming: WorkTypeInputRepresentationNormalized): boolean;
+export declare function deepFreeze(input: WorkTypeInputRepresentation): void;
+export declare const ingest: $64$luvio_engine_ResourceIngest;
+export declare function getTypeCacheKeys(luvio: $64$luvio_engine_Luvio, input: WorkTypeInputRepresentation, fullPathFactory: () => string | $64$luvio_engine_NormalizedKeyMetadata): $64$luvio_engine_DurableStoreKeyMetadataMap;
+/**
+ * Work Type input representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WorkTypeInputRepresentationNormalized {
+    /** Block time after appointment */
+    blockTimeAfterAppointmentInMinutes: number;
+    /** Block time before appointment */
+    blockTimeBeforeAppointmentInMinutes: number;
+    /** Duration in Minutes */
+    durationInMinutes: number;
+    /** Id */
+    id: string;
+    /** Operating Hours Id */
+    operatingHoursId: string;
+    /** Operating Hours Time Zone */
+    operatingHoursTimeZone: string;
+    /** Skill Requirement */
+    skillRequirements: Array<{}>;
+    /** Timeframe end in minutes */
+    timeFrameEndInMinutes: number;
+    /** Timeframe start in minutes */
+    timeFrameStartInMinutes: number;
+}
+/**
+ * Work Type input representation
+ *
+ * Keys:
+ *    (none)
+ */
+export interface WorkTypeInputRepresentation {
+    blockTimeAfterAppointmentInMinutes: number;
+    blockTimeBeforeAppointmentInMinutes: number;
+    durationInMinutes: number;
+    id: string;
+    operatingHoursId: string;
+    operatingHoursTimeZone: string;
+    skillRequirements: Array<{}>;
+    timeFrameEndInMinutes: number;
+    timeFrameStartInMinutes: number;
+}

package/dist/es/es2018/types/src/generated/types/type-utils.d.ts

@@ -0,0 +1,39 @@
+import { NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+export declare const ObjectFreeze: {
+    <T extends Function>(f: T): T;
+    <T_1 extends {
+        [idx: string]: object | U | null | undefined;
+    }, U extends string | number | bigint | boolean | symbol>(o: T_1): Readonly<T_1>;
+    <T_2>(o: T_2): Readonly<T_2>;
+}, ObjectKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, ObjectCreate: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, ObjectAssign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const ArrayIsArray: (arg: any) => arg is any[];
+export declare const JSONStringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+};
+type AllowedPrimitives = boolean | string | number | Date | null;
+type Value<T> = T extends AllowedPrimitives ? T : RecursivePartial<T>;
+export type RecursivePartial<T> = null | {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<Value<U>> | null : Value<T[P]> | null;
+};
+export declare function equalsArray<U, V extends U[]>(a: V, b: V, equalsItem: (itemA: U, itemB: U) => boolean | void): boolean;
+export declare function equalsObject<U, V extends {
+    [key: string]: U;
+}>(a: V, b: V, equalsProp: (propA: U, propB: U) => boolean | void): boolean;
+export declare function deepFreeze(value: any): void;
+export declare function createLink(ref: string | $64$luvio_engine_NormalizedKeyMetadata): {
+    __ref: string;
+};
+export declare function assignMetadataLink(entry: any, metadataKey: string | $64$luvio_engine_NormalizedKeyMetadata): void;
+export {};

package/package.json

@@ -0,0 +1,68 @@
+{
+    "name": "@salesforce/lds-adapters-industries-scheduler",
+    "version": "0.131.0",
+    "description": "Wire adapters for Lightning Scheduler resources",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "main": "dist/es/es2018/industries-scheduler.js",
+    "module": "dist/es/es2018/industries-scheduler.js",
+    "types": "dist/es/es2018/types/src/generated/artifacts/main.d.ts",
+    "files": [
+        "dist",
+        "sfdc",
+        "src/raml/*"
+    ],
+    "exports": {
+        ".": {
+            "import": "./dist/es/es2018/industries-scheduler.js",
+            "require": "./dist/es/es2018/industries-scheduler.js",
+            "types": "./dist/es/es2018/types/src/generated/artifacts/main.d.ts"
+        },
+        "./sfdc": {
+            "import": "./sfdc/index.js",
+            "types": "./sfdc/index.d.ts",
+            "default": "./sfdc/index.js"
+        }
+    },
+    "sdfc": {
+        "namespace": "lightning",
+        "module": "industriesSchedulerApi"
+    },
+    "contributors": [
+        "pavan.puvvada@salesforce.com",
+        "kgoncalves@salesforce.com"
+    ],
+    "scripts": {
+        "build": "yarn build:raml && yarn build:services && yarn build:karma",
+        "build:karma": "rollup --config rollup.config.karma.js",
+        "build:raml": "luvio generate src/raml/luvio.raml src/generated -p '../lds-compiler-plugins'",
+        "build:services": "rollup --config rollup.config.js",
+        "clean": "rm -rf dist sfdc src/generated karma/dist",
+        "release:core": "../../scripts/release/core.js --adapter=lds-adapters-industries-scheduler",
+        "release:corejar": "yarn build && ../core-build/scripts/core.js --adapter=lds-adapters-industries-scheduler",
+        "start": "karma start",
+        "test": "karma start --single-run",
+        "test:compat": "karma start --single-run --compat"
+    },
+    "dependencies": {
+        "@salesforce/lds-bindings": "1.131.0-244.6"
+    },
+    "devDependencies": {
+        "@salesforce/lds-compiler-plugins": "1.131.0-244.6",
+        "@salesforce/lds-karma": "1.131.0-244.6"
+    },
+    "nx": {
+        "targets": {
+            "build": {
+                "outputs": [
+                    "packages/lds-adapters-industries-scheduler/dist",
+                    "packages/lds-adapters-industries-scheduler/karma/dist",
+                    "packages/lds-adapters-industries-scheduler/sfdc",
+                    "packages/lds-adapters-industries-scheduler/src/generated"
+                ]
+            }
+        }
+    },
+    "volta": {
+        "extends": "../../package.json"
+    }
+}

package/sfdc/index.d.ts

@@ -0,0 +1 @@
+export * from '../dist/es/es2018/types/src/generated/artifacts/sfdc';