@memberjunction/core-entities 5.7.0 → 5.9.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/generated/entity_subclasses.d.ts +1519 -21
- package/dist/generated/entity_subclasses.d.ts.map +1 -1
- package/dist/generated/entity_subclasses.js +2366 -113
- package/dist/generated/entity_subclasses.js.map +1 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js.map +1 -1
- package/package.json +5 -5
|
@@ -7660,6 +7660,218 @@ export const MJCompanySchema = z.object({
|
|
|
7660
7660
|
* * SQL Data Type: datetimeoffset
|
|
7661
7661
|
* * Default Value: getutcdate()`),
|
|
7662
7662
|
});
|
|
7663
|
+
/**
|
|
7664
|
+
* zod schema definition for the entity MJ: Company Integration Entity Maps
|
|
7665
|
+
*/
|
|
7666
|
+
export const MJCompanyIntegrationEntityMapSchema = z.object({
|
|
7667
|
+
ID: z.string().describe(`
|
|
7668
|
+
* * Field Name: ID
|
|
7669
|
+
* * Display Name: ID
|
|
7670
|
+
* * SQL Data Type: uniqueidentifier
|
|
7671
|
+
* * Default Value: newsequentialid()`),
|
|
7672
|
+
CompanyIntegrationID: z.string().describe(`
|
|
7673
|
+
* * Field Name: CompanyIntegrationID
|
|
7674
|
+
* * Display Name: Company Integration
|
|
7675
|
+
* * SQL Data Type: uniqueidentifier
|
|
7676
|
+
* * Related Entity/Foreign Key: MJ: Company Integrations (vwCompanyIntegrations.ID)`),
|
|
7677
|
+
ExternalObjectName: z.string().describe(`
|
|
7678
|
+
* * Field Name: ExternalObjectName
|
|
7679
|
+
* * Display Name: External Object Name
|
|
7680
|
+
* * SQL Data Type: nvarchar(500)
|
|
7681
|
+
* * Description: The name of the object in the external system (e.g. table name, API resource name).`),
|
|
7682
|
+
ExternalObjectLabel: z.string().nullable().describe(`
|
|
7683
|
+
* * Field Name: ExternalObjectLabel
|
|
7684
|
+
* * Display Name: External Object Label
|
|
7685
|
+
* * SQL Data Type: nvarchar(500)
|
|
7686
|
+
* * Description: Optional human-friendly label for the external object.`),
|
|
7687
|
+
EntityID: z.string().describe(`
|
|
7688
|
+
* * Field Name: EntityID
|
|
7689
|
+
* * Display Name: Entity
|
|
7690
|
+
* * SQL Data Type: uniqueidentifier
|
|
7691
|
+
* * Related Entity/Foreign Key: MJ: Entities (vwEntities.ID)`),
|
|
7692
|
+
SyncDirection: z.union([z.literal('Bidirectional'), z.literal('Pull'), z.literal('Push')]).describe(`
|
|
7693
|
+
* * Field Name: SyncDirection
|
|
7694
|
+
* * Display Name: Sync Direction
|
|
7695
|
+
* * SQL Data Type: nvarchar(50)
|
|
7696
|
+
* * Default Value: Pull
|
|
7697
|
+
* * Value List Type: List
|
|
7698
|
+
* * Possible Values
|
|
7699
|
+
* * Bidirectional
|
|
7700
|
+
* * Pull
|
|
7701
|
+
* * Push
|
|
7702
|
+
* * Description: Whether data flows from external to MJ (Pull), MJ to external (Push), or both.`),
|
|
7703
|
+
SyncEnabled: z.boolean().describe(`
|
|
7704
|
+
* * Field Name: SyncEnabled
|
|
7705
|
+
* * Display Name: Sync Enabled
|
|
7706
|
+
* * SQL Data Type: bit
|
|
7707
|
+
* * Default Value: 1
|
|
7708
|
+
* * Description: When true, this entity map is included in sync runs.`),
|
|
7709
|
+
MatchStrategy: z.string().nullable().describe(`
|
|
7710
|
+
* * Field Name: MatchStrategy
|
|
7711
|
+
* * Display Name: Match Strategy
|
|
7712
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
7713
|
+
* * Description: JSON configuration for the match engine describing how to identify existing records (key fields, fuzzy thresholds, etc.).`),
|
|
7714
|
+
ConflictResolution: z.union([z.literal('DestWins'), z.literal('Manual'), z.literal('MostRecent'), z.literal('SourceWins')]).describe(`
|
|
7715
|
+
* * Field Name: ConflictResolution
|
|
7716
|
+
* * Display Name: Conflict Resolution
|
|
7717
|
+
* * SQL Data Type: nvarchar(50)
|
|
7718
|
+
* * Default Value: SourceWins
|
|
7719
|
+
* * Value List Type: List
|
|
7720
|
+
* * Possible Values
|
|
7721
|
+
* * DestWins
|
|
7722
|
+
* * Manual
|
|
7723
|
+
* * MostRecent
|
|
7724
|
+
* * SourceWins
|
|
7725
|
+
* * Description: How to handle conflicts when both source and destination have been modified. SourceWins, DestWins, MostRecent, or Manual.`),
|
|
7726
|
+
Priority: z.number().describe(`
|
|
7727
|
+
* * Field Name: Priority
|
|
7728
|
+
* * Display Name: Priority
|
|
7729
|
+
* * SQL Data Type: int
|
|
7730
|
+
* * Default Value: 0
|
|
7731
|
+
* * Description: Processing order when multiple entity maps exist. Lower numbers are processed first.`),
|
|
7732
|
+
DeleteBehavior: z.union([z.literal('DoNothing'), z.literal('HardDelete'), z.literal('SoftDelete')]).describe(`
|
|
7733
|
+
* * Field Name: DeleteBehavior
|
|
7734
|
+
* * Display Name: Delete Behavior
|
|
7735
|
+
* * SQL Data Type: nvarchar(50)
|
|
7736
|
+
* * Default Value: SoftDelete
|
|
7737
|
+
* * Value List Type: List
|
|
7738
|
+
* * Possible Values
|
|
7739
|
+
* * DoNothing
|
|
7740
|
+
* * HardDelete
|
|
7741
|
+
* * SoftDelete
|
|
7742
|
+
* * Description: How to handle records that no longer exist in the source. SoftDelete, DoNothing, or HardDelete.`),
|
|
7743
|
+
Status: z.union([z.literal('Active'), z.literal('Inactive')]).describe(`
|
|
7744
|
+
* * Field Name: Status
|
|
7745
|
+
* * Display Name: Status
|
|
7746
|
+
* * SQL Data Type: nvarchar(50)
|
|
7747
|
+
* * Default Value: Active
|
|
7748
|
+
* * Value List Type: List
|
|
7749
|
+
* * Possible Values
|
|
7750
|
+
* * Active
|
|
7751
|
+
* * Inactive
|
|
7752
|
+
* * Description: Whether this entity map is Active or Inactive.`),
|
|
7753
|
+
Configuration: z.string().nullable().describe(`
|
|
7754
|
+
* * Field Name: Configuration
|
|
7755
|
+
* * Display Name: Configuration
|
|
7756
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
7757
|
+
* * Description: Optional JSON configuration specific to this entity mapping.`),
|
|
7758
|
+
__mj_CreatedAt: z.date().describe(`
|
|
7759
|
+
* * Field Name: __mj_CreatedAt
|
|
7760
|
+
* * Display Name: Created At
|
|
7761
|
+
* * SQL Data Type: datetimeoffset
|
|
7762
|
+
* * Default Value: getutcdate()`),
|
|
7763
|
+
__mj_UpdatedAt: z.date().describe(`
|
|
7764
|
+
* * Field Name: __mj_UpdatedAt
|
|
7765
|
+
* * Display Name: Updated At
|
|
7766
|
+
* * SQL Data Type: datetimeoffset
|
|
7767
|
+
* * Default Value: getutcdate()`),
|
|
7768
|
+
CompanyIntegration: z.string().describe(`
|
|
7769
|
+
* * Field Name: CompanyIntegration
|
|
7770
|
+
* * Display Name: Company Integration Name
|
|
7771
|
+
* * SQL Data Type: nvarchar(255)`),
|
|
7772
|
+
Entity: z.string().describe(`
|
|
7773
|
+
* * Field Name: Entity
|
|
7774
|
+
* * Display Name: Entity Name
|
|
7775
|
+
* * SQL Data Type: nvarchar(255)`),
|
|
7776
|
+
});
|
|
7777
|
+
/**
|
|
7778
|
+
* zod schema definition for the entity MJ: Company Integration Field Maps
|
|
7779
|
+
*/
|
|
7780
|
+
export const MJCompanyIntegrationFieldMapSchema = z.object({
|
|
7781
|
+
ID: z.string().describe(`
|
|
7782
|
+
* * Field Name: ID
|
|
7783
|
+
* * Display Name: ID
|
|
7784
|
+
* * SQL Data Type: uniqueidentifier
|
|
7785
|
+
* * Default Value: newsequentialid()`),
|
|
7786
|
+
EntityMapID: z.string().describe(`
|
|
7787
|
+
* * Field Name: EntityMapID
|
|
7788
|
+
* * Display Name: Entity Map ID
|
|
7789
|
+
* * SQL Data Type: uniqueidentifier
|
|
7790
|
+
* * Related Entity/Foreign Key: MJ: Company Integration Entity Maps (vwCompanyIntegrationEntityMaps.ID)`),
|
|
7791
|
+
SourceFieldName: z.string().describe(`
|
|
7792
|
+
* * Field Name: SourceFieldName
|
|
7793
|
+
* * Display Name: Source Field Name
|
|
7794
|
+
* * SQL Data Type: nvarchar(500)
|
|
7795
|
+
* * Description: The field/column name in the external source system.`),
|
|
7796
|
+
SourceFieldLabel: z.string().nullable().describe(`
|
|
7797
|
+
* * Field Name: SourceFieldLabel
|
|
7798
|
+
* * Display Name: Source Field Label
|
|
7799
|
+
* * SQL Data Type: nvarchar(500)
|
|
7800
|
+
* * Description: Optional human-friendly label for the source field.`),
|
|
7801
|
+
DestinationFieldName: z.string().describe(`
|
|
7802
|
+
* * Field Name: DestinationFieldName
|
|
7803
|
+
* * Display Name: Destination Field Name
|
|
7804
|
+
* * SQL Data Type: nvarchar(500)
|
|
7805
|
+
* * Description: The MJ entity field name this source field maps to.`),
|
|
7806
|
+
DestinationFieldLabel: z.string().nullable().describe(`
|
|
7807
|
+
* * Field Name: DestinationFieldLabel
|
|
7808
|
+
* * Display Name: Destination Field Label
|
|
7809
|
+
* * SQL Data Type: nvarchar(500)
|
|
7810
|
+
* * Description: Optional human-friendly label for the destination field.`),
|
|
7811
|
+
Direction: z.union([z.literal('Both'), z.literal('DestToSource'), z.literal('SourceToDest')]).describe(`
|
|
7812
|
+
* * Field Name: Direction
|
|
7813
|
+
* * Display Name: Direction
|
|
7814
|
+
* * SQL Data Type: nvarchar(50)
|
|
7815
|
+
* * Default Value: SourceToDest
|
|
7816
|
+
* * Value List Type: List
|
|
7817
|
+
* * Possible Values
|
|
7818
|
+
* * Both
|
|
7819
|
+
* * DestToSource
|
|
7820
|
+
* * SourceToDest
|
|
7821
|
+
* * Description: Direction of field mapping: SourceToDest, DestToSource, or Both.`),
|
|
7822
|
+
TransformPipeline: z.string().nullable().describe(`
|
|
7823
|
+
* * Field Name: TransformPipeline
|
|
7824
|
+
* * Display Name: Transform Pipeline
|
|
7825
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
7826
|
+
* * Description: JSON array of transform names to apply in order (e.g. ["trim", "uppercase"]). See FieldMappingEngine for available transforms.`),
|
|
7827
|
+
IsKeyField: z.boolean().describe(`
|
|
7828
|
+
* * Field Name: IsKeyField
|
|
7829
|
+
* * Display Name: Is Key Field
|
|
7830
|
+
* * SQL Data Type: bit
|
|
7831
|
+
* * Default Value: 0
|
|
7832
|
+
* * Description: When true, this field is used by the MatchEngine to find existing records during sync.`),
|
|
7833
|
+
IsRequired: z.boolean().describe(`
|
|
7834
|
+
* * Field Name: IsRequired
|
|
7835
|
+
* * Display Name: Is Required
|
|
7836
|
+
* * SQL Data Type: bit
|
|
7837
|
+
* * Default Value: 0
|
|
7838
|
+
* * Description: When true, a sync record is rejected if this field has no value.`),
|
|
7839
|
+
DefaultValue: z.string().nullable().describe(`
|
|
7840
|
+
* * Field Name: DefaultValue
|
|
7841
|
+
* * Display Name: Default Value
|
|
7842
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
7843
|
+
* * Description: Default value to use when the source field is null or missing.`),
|
|
7844
|
+
Priority: z.number().describe(`
|
|
7845
|
+
* * Field Name: Priority
|
|
7846
|
+
* * Display Name: Priority
|
|
7847
|
+
* * SQL Data Type: int
|
|
7848
|
+
* * Default Value: 0
|
|
7849
|
+
* * Description: Processing order for this field mapping within the entity map.`),
|
|
7850
|
+
Status: z.union([z.literal('Active'), z.literal('Inactive')]).describe(`
|
|
7851
|
+
* * Field Name: Status
|
|
7852
|
+
* * Display Name: Status
|
|
7853
|
+
* * SQL Data Type: nvarchar(50)
|
|
7854
|
+
* * Default Value: Active
|
|
7855
|
+
* * Value List Type: List
|
|
7856
|
+
* * Possible Values
|
|
7857
|
+
* * Active
|
|
7858
|
+
* * Inactive
|
|
7859
|
+
* * Description: Whether this field mapping is Active or Inactive.`),
|
|
7860
|
+
__mj_CreatedAt: z.date().describe(`
|
|
7861
|
+
* * Field Name: __mj_CreatedAt
|
|
7862
|
+
* * Display Name: Created At
|
|
7863
|
+
* * SQL Data Type: datetimeoffset
|
|
7864
|
+
* * Default Value: getutcdate()`),
|
|
7865
|
+
__mj_UpdatedAt: z.date().describe(`
|
|
7866
|
+
* * Field Name: __mj_UpdatedAt
|
|
7867
|
+
* * Display Name: Updated At
|
|
7868
|
+
* * SQL Data Type: datetimeoffset
|
|
7869
|
+
* * Default Value: getutcdate()`),
|
|
7870
|
+
EntityMap: z.string().describe(`
|
|
7871
|
+
* * Field Name: EntityMap
|
|
7872
|
+
* * Display Name: Entity Map
|
|
7873
|
+
* * SQL Data Type: nvarchar(500)`),
|
|
7874
|
+
});
|
|
7663
7875
|
/**
|
|
7664
7876
|
* zod schema definition for the entity MJ: Company Integration Record Maps
|
|
7665
7877
|
*/
|
|
@@ -7918,6 +8130,73 @@ export const MJCompanyIntegrationRunSchema = z.object({
|
|
|
7918
8130
|
* * Display Name: Run By User
|
|
7919
8131
|
* * SQL Data Type: nvarchar(100)`),
|
|
7920
8132
|
});
|
|
8133
|
+
/**
|
|
8134
|
+
* zod schema definition for the entity MJ: Company Integration Sync Watermarks
|
|
8135
|
+
*/
|
|
8136
|
+
export const MJCompanyIntegrationSyncWatermarkSchema = z.object({
|
|
8137
|
+
ID: z.string().describe(`
|
|
8138
|
+
* * Field Name: ID
|
|
8139
|
+
* * Display Name: ID
|
|
8140
|
+
* * SQL Data Type: uniqueidentifier
|
|
8141
|
+
* * Default Value: newsequentialid()`),
|
|
8142
|
+
EntityMapID: z.string().describe(`
|
|
8143
|
+
* * Field Name: EntityMapID
|
|
8144
|
+
* * Display Name: Entity Map
|
|
8145
|
+
* * SQL Data Type: uniqueidentifier
|
|
8146
|
+
* * Related Entity/Foreign Key: MJ: Company Integration Entity Maps (vwCompanyIntegrationEntityMaps.ID)`),
|
|
8147
|
+
Direction: z.union([z.literal('Pull'), z.literal('Push')]).describe(`
|
|
8148
|
+
* * Field Name: Direction
|
|
8149
|
+
* * Display Name: Direction
|
|
8150
|
+
* * SQL Data Type: nvarchar(50)
|
|
8151
|
+
* * Default Value: Pull
|
|
8152
|
+
* * Value List Type: List
|
|
8153
|
+
* * Possible Values
|
|
8154
|
+
* * Pull
|
|
8155
|
+
* * Push
|
|
8156
|
+
* * Description: Sync direction this watermark tracks: Pull or Push.`),
|
|
8157
|
+
WatermarkType: z.union([z.literal('ChangeToken'), z.literal('Cursor'), z.literal('Timestamp'), z.literal('Version')]).describe(`
|
|
8158
|
+
* * Field Name: WatermarkType
|
|
8159
|
+
* * Display Name: Watermark Type
|
|
8160
|
+
* * SQL Data Type: nvarchar(50)
|
|
8161
|
+
* * Default Value: Timestamp
|
|
8162
|
+
* * Value List Type: List
|
|
8163
|
+
* * Possible Values
|
|
8164
|
+
* * ChangeToken
|
|
8165
|
+
* * Cursor
|
|
8166
|
+
* * Timestamp
|
|
8167
|
+
* * Version
|
|
8168
|
+
* * Description: The type of watermark: Timestamp, Cursor, ChangeToken, or Version.`),
|
|
8169
|
+
WatermarkValue: z.string().nullable().describe(`
|
|
8170
|
+
* * Field Name: WatermarkValue
|
|
8171
|
+
* * Display Name: Watermark Value
|
|
8172
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
8173
|
+
* * Description: The serialized watermark value used to resume incremental sync.`),
|
|
8174
|
+
LastSyncAt: z.date().nullable().describe(`
|
|
8175
|
+
* * Field Name: LastSyncAt
|
|
8176
|
+
* * Display Name: Last Sync At
|
|
8177
|
+
* * SQL Data Type: datetimeoffset
|
|
8178
|
+
* * Description: Timestamp of the last successful sync for this watermark.`),
|
|
8179
|
+
RecordsSynced: z.number().describe(`
|
|
8180
|
+
* * Field Name: RecordsSynced
|
|
8181
|
+
* * Display Name: Records Synced
|
|
8182
|
+
* * SQL Data Type: int
|
|
8183
|
+
* * Default Value: 0
|
|
8184
|
+
* * Description: Cumulative count of records synced through this watermark.`),
|
|
8185
|
+
__mj_CreatedAt: z.date().describe(`
|
|
8186
|
+
* * Field Name: __mj_CreatedAt
|
|
8187
|
+
* * Display Name: Created At
|
|
8188
|
+
* * SQL Data Type: datetimeoffset
|
|
8189
|
+
* * Default Value: getutcdate()`),
|
|
8190
|
+
__mj_UpdatedAt: z.date().describe(`
|
|
8191
|
+
* * Field Name: __mj_UpdatedAt
|
|
8192
|
+
* * Display Name: Updated At
|
|
8193
|
+
* * SQL Data Type: datetimeoffset
|
|
8194
|
+
* * Default Value: getutcdate()`),
|
|
8195
|
+
EntityMap: z.string().describe(`
|
|
8196
|
+
* * Field Name: EntityMap
|
|
8197
|
+
* * Display Name: Entity Map Name
|
|
8198
|
+
* * SQL Data Type: nvarchar(500)`),
|
|
8199
|
+
});
|
|
7921
8200
|
/**
|
|
7922
8201
|
* zod schema definition for the entity MJ: Company Integrations
|
|
7923
8202
|
*/
|
|
@@ -7939,7 +8218,7 @@ export const MJCompanyIntegrationSchema = z.object({
|
|
|
7939
8218
|
* * Related Entity/Foreign Key: MJ: Integrations (vwIntegrations.ID)`),
|
|
7940
8219
|
IsActive: z.boolean().nullable().describe(`
|
|
7941
8220
|
* * Field Name: IsActive
|
|
7942
|
-
* * Display Name: Active
|
|
8221
|
+
* * Display Name: Is Active
|
|
7943
8222
|
* * SQL Data Type: bit
|
|
7944
8223
|
* * Description: Controls whether this integration is currently active for the company.`),
|
|
7945
8224
|
AccessToken: z.string().nullable().describe(`
|
|
@@ -8003,6 +8282,81 @@ export const MJCompanyIntegrationSchema = z.object({
|
|
|
8003
8282
|
* * Display Name: Name
|
|
8004
8283
|
* * SQL Data Type: nvarchar(255)
|
|
8005
8284
|
* * Description: User-friendly name for the company integration instance, typically in the format "Company: Integration".`),
|
|
8285
|
+
SourceTypeID: z.string().nullable().describe(`
|
|
8286
|
+
* * Field Name: SourceTypeID
|
|
8287
|
+
* * Display Name: Source Type
|
|
8288
|
+
* * SQL Data Type: uniqueidentifier
|
|
8289
|
+
* * Related Entity/Foreign Key: MJ: Integration Source Types (vwIntegrationSourceTypes.ID)
|
|
8290
|
+
* * Description: Links this integration to its source type (SaaS API, Database, File Feed, etc.).`),
|
|
8291
|
+
Configuration: z.string().nullable().describe(`
|
|
8292
|
+
* * Field Name: Configuration
|
|
8293
|
+
* * Display Name: Configuration
|
|
8294
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
8295
|
+
* * Description: JSON configuration for the integration connection (server, database, credentials reference, etc.).`),
|
|
8296
|
+
CredentialID: z.string().nullable().describe(`
|
|
8297
|
+
* * Field Name: CredentialID
|
|
8298
|
+
* * Display Name: Credential
|
|
8299
|
+
* * SQL Data Type: uniqueidentifier
|
|
8300
|
+
* * Related Entity/Foreign Key: MJ: Credentials (vwCredentials.ID)
|
|
8301
|
+
* * Description: Optional reference to a Credential record that stores encrypted authentication values for this company integration. Replaces the legacy inline auth fields (AccessToken, RefreshToken, APIKey, etc.).`),
|
|
8302
|
+
ScheduleEnabled: z.boolean().describe(`
|
|
8303
|
+
* * Field Name: ScheduleEnabled
|
|
8304
|
+
* * Display Name: Schedule Enabled
|
|
8305
|
+
* * SQL Data Type: bit
|
|
8306
|
+
* * Default Value: 0
|
|
8307
|
+
* * Description: Whether automatic sync scheduling is enabled for this integration`),
|
|
8308
|
+
ScheduleType: z.union([z.literal('Cron'), z.literal('Interval'), z.literal('Manual')]).describe(`
|
|
8309
|
+
* * Field Name: ScheduleType
|
|
8310
|
+
* * Display Name: Schedule Type
|
|
8311
|
+
* * SQL Data Type: nvarchar(20)
|
|
8312
|
+
* * Default Value: Manual
|
|
8313
|
+
* * Value List Type: List
|
|
8314
|
+
* * Possible Values
|
|
8315
|
+
* * Cron
|
|
8316
|
+
* * Interval
|
|
8317
|
+
* * Manual
|
|
8318
|
+
* * Description: Type of schedule: Manual (no auto-sync), Interval (every N minutes), Cron (cron expression)`),
|
|
8319
|
+
ScheduleIntervalMinutes: z.number().nullable().describe(`
|
|
8320
|
+
* * Field Name: ScheduleIntervalMinutes
|
|
8321
|
+
* * Display Name: Schedule Interval (Minutes)
|
|
8322
|
+
* * SQL Data Type: int
|
|
8323
|
+
* * Description: Interval in minutes for Interval schedule type`),
|
|
8324
|
+
CronExpression: z.string().nullable().describe(`
|
|
8325
|
+
* * Field Name: CronExpression
|
|
8326
|
+
* * Display Name: Cron Expression
|
|
8327
|
+
* * SQL Data Type: nvarchar(200)
|
|
8328
|
+
* * Description: Cron expression for Cron schedule type (e.g., "0 *\/6 * * *" for every 6 hours)`),
|
|
8329
|
+
NextScheduledRunAt: z.date().nullable().describe(`
|
|
8330
|
+
* * Field Name: NextScheduledRunAt
|
|
8331
|
+
* * Display Name: Next Scheduled Run
|
|
8332
|
+
* * SQL Data Type: datetimeoffset
|
|
8333
|
+
* * Description: When the next scheduled sync should run. Updated after each run based on schedule config.`),
|
|
8334
|
+
LastScheduledRunAt: z.date().nullable().describe(`
|
|
8335
|
+
* * Field Name: LastScheduledRunAt
|
|
8336
|
+
* * Display Name: Last Scheduled Run
|
|
8337
|
+
* * SQL Data Type: datetimeoffset
|
|
8338
|
+
* * Description: When the last scheduled sync was initiated`),
|
|
8339
|
+
IsLocked: z.boolean().describe(`
|
|
8340
|
+
* * Field Name: IsLocked
|
|
8341
|
+
* * Display Name: Is Locked
|
|
8342
|
+
* * SQL Data Type: bit
|
|
8343
|
+
* * Default Value: 0
|
|
8344
|
+
* * Description: Whether a sync is currently locked/running for this integration`),
|
|
8345
|
+
LockedAt: z.date().nullable().describe(`
|
|
8346
|
+
* * Field Name: LockedAt
|
|
8347
|
+
* * Display Name: Locked At
|
|
8348
|
+
* * SQL Data Type: datetimeoffset
|
|
8349
|
+
* * Description: When the lock was acquired`),
|
|
8350
|
+
LockedByInstance: z.string().nullable().describe(`
|
|
8351
|
+
* * Field Name: LockedByInstance
|
|
8352
|
+
* * Display Name: Locked By Instance
|
|
8353
|
+
* * SQL Data Type: nvarchar(200)
|
|
8354
|
+
* * Description: Server instance identifier that holds the lock (hostname-pid)`),
|
|
8355
|
+
LockExpiresAt: z.date().nullable().describe(`
|
|
8356
|
+
* * Field Name: LockExpiresAt
|
|
8357
|
+
* * Display Name: Lock Expires At
|
|
8358
|
+
* * SQL Data Type: datetimeoffset
|
|
8359
|
+
* * Description: When the lock should be considered stale and eligible for cleanup`),
|
|
8006
8360
|
Company: z.string().describe(`
|
|
8007
8361
|
* * Field Name: Company
|
|
8008
8362
|
* * Display Name: Company
|
|
@@ -13788,6 +14142,323 @@ export const MJGeneratedCodeSchema = z.object({
|
|
|
13788
14142
|
* * Display Name: Linked Entity
|
|
13789
14143
|
* * SQL Data Type: nvarchar(255)`),
|
|
13790
14144
|
});
|
|
14145
|
+
/**
|
|
14146
|
+
* zod schema definition for the entity MJ: Integration Object Fields
|
|
14147
|
+
*/
|
|
14148
|
+
export const MJIntegrationObjectFieldSchema = z.object({
|
|
14149
|
+
ID: z.string().describe(`
|
|
14150
|
+
* * Field Name: ID
|
|
14151
|
+
* * Display Name: ID
|
|
14152
|
+
* * SQL Data Type: uniqueidentifier
|
|
14153
|
+
* * Default Value: newsequentialid()
|
|
14154
|
+
* * Description: Primary key`),
|
|
14155
|
+
IntegrationObjectID: z.string().describe(`
|
|
14156
|
+
* * Field Name: IntegrationObjectID
|
|
14157
|
+
* * Display Name: Integration Object
|
|
14158
|
+
* * SQL Data Type: uniqueidentifier
|
|
14159
|
+
* * Related Entity/Foreign Key: MJ: Integration Objects (vwIntegrationObjects.ID)
|
|
14160
|
+
* * Description: Foreign key to the IntegrationObject this field belongs to`),
|
|
14161
|
+
Name: z.string().describe(`
|
|
14162
|
+
* * Field Name: Name
|
|
14163
|
+
* * Display Name: Name
|
|
14164
|
+
* * SQL Data Type: nvarchar(255)
|
|
14165
|
+
* * Description: Field name as returned by the external API`),
|
|
14166
|
+
DisplayName: z.string().nullable().describe(`
|
|
14167
|
+
* * Field Name: DisplayName
|
|
14168
|
+
* * Display Name: Display Name
|
|
14169
|
+
* * SQL Data Type: nvarchar(255)
|
|
14170
|
+
* * Description: Human-friendly display label for the field`),
|
|
14171
|
+
Description: z.string().nullable().describe(`
|
|
14172
|
+
* * Field Name: Description
|
|
14173
|
+
* * Display Name: Description
|
|
14174
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
14175
|
+
* * Description: Description of what this field represents`),
|
|
14176
|
+
Category: z.string().nullable().describe(`
|
|
14177
|
+
* * Field Name: Category
|
|
14178
|
+
* * Display Name: Category
|
|
14179
|
+
* * SQL Data Type: nvarchar(100)
|
|
14180
|
+
* * Description: UI grouping category within the object`),
|
|
14181
|
+
Type: z.string().describe(`
|
|
14182
|
+
* * Field Name: Type
|
|
14183
|
+
* * Display Name: Type
|
|
14184
|
+
* * SQL Data Type: nvarchar(100)
|
|
14185
|
+
* * Description: Data type of the field (e.g., nvarchar, int, datetime, decimal, bit). Uses same type vocabulary as EntityField.`),
|
|
14186
|
+
Length: z.number().nullable().describe(`
|
|
14187
|
+
* * Field Name: Length
|
|
14188
|
+
* * Display Name: Length
|
|
14189
|
+
* * SQL Data Type: int
|
|
14190
|
+
* * Description: Maximum length for string types`),
|
|
14191
|
+
Precision: z.number().nullable().describe(`
|
|
14192
|
+
* * Field Name: Precision
|
|
14193
|
+
* * Display Name: Precision
|
|
14194
|
+
* * SQL Data Type: int
|
|
14195
|
+
* * Description: Numeric precision`),
|
|
14196
|
+
Scale: z.number().nullable().describe(`
|
|
14197
|
+
* * Field Name: Scale
|
|
14198
|
+
* * Display Name: Scale
|
|
14199
|
+
* * SQL Data Type: int
|
|
14200
|
+
* * Description: Numeric scale`),
|
|
14201
|
+
AllowsNull: z.boolean().describe(`
|
|
14202
|
+
* * Field Name: AllowsNull
|
|
14203
|
+
* * Display Name: Allows Null
|
|
14204
|
+
* * SQL Data Type: bit
|
|
14205
|
+
* * Default Value: 1
|
|
14206
|
+
* * Description: Whether the field can contain NULL values`),
|
|
14207
|
+
DefaultValue: z.string().nullable().describe(`
|
|
14208
|
+
* * Field Name: DefaultValue
|
|
14209
|
+
* * Display Name: Default Value
|
|
14210
|
+
* * SQL Data Type: nvarchar(255)
|
|
14211
|
+
* * Description: Default value from the source system`),
|
|
14212
|
+
IsPrimaryKey: z.boolean().describe(`
|
|
14213
|
+
* * Field Name: IsPrimaryKey
|
|
14214
|
+
* * Display Name: Primary Key
|
|
14215
|
+
* * SQL Data Type: bit
|
|
14216
|
+
* * Default Value: 0
|
|
14217
|
+
* * Description: Whether this field is part of the object primary key`),
|
|
14218
|
+
IsUniqueKey: z.boolean().describe(`
|
|
14219
|
+
* * Field Name: IsUniqueKey
|
|
14220
|
+
* * Display Name: Unique Key
|
|
14221
|
+
* * SQL Data Type: bit
|
|
14222
|
+
* * Default Value: 0
|
|
14223
|
+
* * Description: Whether values must be unique across all records`),
|
|
14224
|
+
IsReadOnly: z.boolean().describe(`
|
|
14225
|
+
* * Field Name: IsReadOnly
|
|
14226
|
+
* * Display Name: Read Only
|
|
14227
|
+
* * SQL Data Type: bit
|
|
14228
|
+
* * Default Value: 0
|
|
14229
|
+
* * Description: Whether this field cannot be written back to the source system`),
|
|
14230
|
+
IsRequired: z.boolean().describe(`
|
|
14231
|
+
* * Field Name: IsRequired
|
|
14232
|
+
* * Display Name: Required
|
|
14233
|
+
* * SQL Data Type: bit
|
|
14234
|
+
* * Default Value: 0
|
|
14235
|
+
* * Description: Whether this field is required for create/update operations`),
|
|
14236
|
+
RelatedIntegrationObjectID: z.string().nullable().describe(`
|
|
14237
|
+
* * Field Name: RelatedIntegrationObjectID
|
|
14238
|
+
* * Display Name: Related Integration Object
|
|
14239
|
+
* * SQL Data Type: uniqueidentifier
|
|
14240
|
+
* * Related Entity/Foreign Key: MJ: Integration Objects (vwIntegrationObjects.ID)
|
|
14241
|
+
* * Description: Foreign key to another IntegrationObject, establishing a relationship. Used for DAG-based dependency ordering and template variable resolution in parent APIPath patterns.`),
|
|
14242
|
+
RelatedIntegrationObjectFieldName: z.string().nullable().describe(`
|
|
14243
|
+
* * Field Name: RelatedIntegrationObjectFieldName
|
|
14244
|
+
* * Display Name: Related Field Name
|
|
14245
|
+
* * SQL Data Type: nvarchar(255)
|
|
14246
|
+
* * Description: The field name on the related IntegrationObject that this FK points to (typically the PK field)`),
|
|
14247
|
+
Sequence: z.number().describe(`
|
|
14248
|
+
* * Field Name: Sequence
|
|
14249
|
+
* * Display Name: Sequence
|
|
14250
|
+
* * SQL Data Type: int
|
|
14251
|
+
* * Default Value: 0
|
|
14252
|
+
* * Description: Display and processing order within the object. Lower numbers appear first.`),
|
|
14253
|
+
Configuration: z.string().nullable().describe(`
|
|
14254
|
+
* * Field Name: Configuration
|
|
14255
|
+
* * Display Name: Configuration
|
|
14256
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
14257
|
+
* * Description: Freeform JSON for connector-specific field configuration`),
|
|
14258
|
+
Status: z.union([z.literal('Active'), z.literal('Deprecated'), z.literal('Disabled')]).describe(`
|
|
14259
|
+
* * Field Name: Status
|
|
14260
|
+
* * Display Name: Status
|
|
14261
|
+
* * SQL Data Type: nvarchar(25)
|
|
14262
|
+
* * Default Value: Active
|
|
14263
|
+
* * Value List Type: List
|
|
14264
|
+
* * Possible Values
|
|
14265
|
+
* * Active
|
|
14266
|
+
* * Deprecated
|
|
14267
|
+
* * Disabled
|
|
14268
|
+
* * Description: Active, Deprecated, or Disabled. Mirrors EntityField status values.`),
|
|
14269
|
+
__mj_CreatedAt: z.date().describe(`
|
|
14270
|
+
* * Field Name: __mj_CreatedAt
|
|
14271
|
+
* * Display Name: Created At
|
|
14272
|
+
* * SQL Data Type: datetimeoffset
|
|
14273
|
+
* * Default Value: getutcdate()`),
|
|
14274
|
+
__mj_UpdatedAt: z.date().describe(`
|
|
14275
|
+
* * Field Name: __mj_UpdatedAt
|
|
14276
|
+
* * Display Name: Updated At
|
|
14277
|
+
* * SQL Data Type: datetimeoffset
|
|
14278
|
+
* * Default Value: getutcdate()`),
|
|
14279
|
+
IntegrationObject: z.string().describe(`
|
|
14280
|
+
* * Field Name: IntegrationObject
|
|
14281
|
+
* * Display Name: Integration Object Name
|
|
14282
|
+
* * SQL Data Type: nvarchar(255)`),
|
|
14283
|
+
RelatedIntegrationObject: z.string().nullable().describe(`
|
|
14284
|
+
* * Field Name: RelatedIntegrationObject
|
|
14285
|
+
* * Display Name: Related Object Name
|
|
14286
|
+
* * SQL Data Type: nvarchar(255)`),
|
|
14287
|
+
});
|
|
14288
|
+
/**
|
|
14289
|
+
* zod schema definition for the entity MJ: Integration Objects
|
|
14290
|
+
*/
|
|
14291
|
+
export const MJIntegrationObjectSchema = z.object({
|
|
14292
|
+
ID: z.string().describe(`
|
|
14293
|
+
* * Field Name: ID
|
|
14294
|
+
* * Display Name: ID
|
|
14295
|
+
* * SQL Data Type: uniqueidentifier
|
|
14296
|
+
* * Default Value: newsequentialid()
|
|
14297
|
+
* * Description: Primary key`),
|
|
14298
|
+
IntegrationID: z.string().describe(`
|
|
14299
|
+
* * Field Name: IntegrationID
|
|
14300
|
+
* * Display Name: Integration
|
|
14301
|
+
* * SQL Data Type: uniqueidentifier
|
|
14302
|
+
* * Related Entity/Foreign Key: MJ: Integrations (vwIntegrations.ID)
|
|
14303
|
+
* * Description: Foreign key to the Integration that owns this object`),
|
|
14304
|
+
Name: z.string().describe(`
|
|
14305
|
+
* * Field Name: Name
|
|
14306
|
+
* * Display Name: Internal Name
|
|
14307
|
+
* * SQL Data Type: nvarchar(255)
|
|
14308
|
+
* * Description: Internal/programmatic name of the external object (e.g., Members, Events)`),
|
|
14309
|
+
DisplayName: z.string().nullable().describe(`
|
|
14310
|
+
* * Field Name: DisplayName
|
|
14311
|
+
* * Display Name: Display Name
|
|
14312
|
+
* * SQL Data Type: nvarchar(255)
|
|
14313
|
+
* * Description: Human-friendly display label`),
|
|
14314
|
+
Description: z.string().nullable().describe(`
|
|
14315
|
+
* * Field Name: Description
|
|
14316
|
+
* * Display Name: Description
|
|
14317
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
14318
|
+
* * Description: Description of what this external object represents`),
|
|
14319
|
+
Category: z.string().nullable().describe(`
|
|
14320
|
+
* * Field Name: Category
|
|
14321
|
+
* * Display Name: Category
|
|
14322
|
+
* * SQL Data Type: nvarchar(100)
|
|
14323
|
+
* * Description: UI grouping category (e.g., Membership, Events, Finance)`),
|
|
14324
|
+
APIPath: z.string().describe(`
|
|
14325
|
+
* * Field Name: APIPath
|
|
14326
|
+
* * Display Name: API Path
|
|
14327
|
+
* * SQL Data Type: nvarchar(500)
|
|
14328
|
+
* * Description: API endpoint path, may include template variables like {ProfileID} that are resolved at runtime from parent object records`),
|
|
14329
|
+
ResponseDataKey: z.string().nullable().describe(`
|
|
14330
|
+
* * Field Name: ResponseDataKey
|
|
14331
|
+
* * Display Name: Response Data Key
|
|
14332
|
+
* * SQL Data Type: nvarchar(255)
|
|
14333
|
+
* * Description: JSON key used to extract the data array from the API response envelope. NULL means the response is a root-level array.`),
|
|
14334
|
+
DefaultPageSize: z.number().describe(`
|
|
14335
|
+
* * Field Name: DefaultPageSize
|
|
14336
|
+
* * Display Name: Default Page Size
|
|
14337
|
+
* * SQL Data Type: int
|
|
14338
|
+
* * Default Value: 100
|
|
14339
|
+
* * Description: Number of records to request per page from the API`),
|
|
14340
|
+
SupportsPagination: z.boolean().describe(`
|
|
14341
|
+
* * Field Name: SupportsPagination
|
|
14342
|
+
* * Display Name: Supports Pagination
|
|
14343
|
+
* * SQL Data Type: bit
|
|
14344
|
+
* * Default Value: 1
|
|
14345
|
+
* * Description: Whether this endpoint supports paginated fetching`),
|
|
14346
|
+
PaginationType: z.union([z.literal('Cursor'), z.literal('None'), z.literal('Offset'), z.literal('PageNumber')]).describe(`
|
|
14347
|
+
* * Field Name: PaginationType
|
|
14348
|
+
* * Display Name: Pagination Type
|
|
14349
|
+
* * SQL Data Type: nvarchar(20)
|
|
14350
|
+
* * Default Value: PageNumber
|
|
14351
|
+
* * Value List Type: List
|
|
14352
|
+
* * Possible Values
|
|
14353
|
+
* * Cursor
|
|
14354
|
+
* * None
|
|
14355
|
+
* * Offset
|
|
14356
|
+
* * PageNumber
|
|
14357
|
+
* * Description: Pagination strategy: PageNumber (page index), Offset (record offset), Cursor (opaque token), or None`),
|
|
14358
|
+
SupportsIncrementalSync: z.boolean().describe(`
|
|
14359
|
+
* * Field Name: SupportsIncrementalSync
|
|
14360
|
+
* * Display Name: Supports Incremental Sync
|
|
14361
|
+
* * SQL Data Type: bit
|
|
14362
|
+
* * Default Value: 0
|
|
14363
|
+
* * Description: Whether this object supports watermark-based incremental sync`),
|
|
14364
|
+
SupportsWrite: z.boolean().describe(`
|
|
14365
|
+
* * Field Name: SupportsWrite
|
|
14366
|
+
* * Display Name: Supports Write
|
|
14367
|
+
* * SQL Data Type: bit
|
|
14368
|
+
* * Default Value: 0
|
|
14369
|
+
* * Description: Whether data can be pushed back to this object via the API`),
|
|
14370
|
+
DefaultQueryParams: z.string().nullable().describe(`
|
|
14371
|
+
* * Field Name: DefaultQueryParams
|
|
14372
|
+
* * Display Name: Default Query Parameters
|
|
14373
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
14374
|
+
* * Description: JSON object of default query parameters to include with every API request for this object`),
|
|
14375
|
+
Configuration: z.string().nullable().describe(`
|
|
14376
|
+
* * Field Name: Configuration
|
|
14377
|
+
* * Display Name: Configuration
|
|
14378
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
14379
|
+
* * Description: Freeform JSON for connector-specific configuration not covered by standard columns`),
|
|
14380
|
+
Sequence: z.number().describe(`
|
|
14381
|
+
* * Field Name: Sequence
|
|
14382
|
+
* * Display Name: Sequence
|
|
14383
|
+
* * SQL Data Type: int
|
|
14384
|
+
* * Default Value: 0
|
|
14385
|
+
* * Description: Processing and display order. Lower numbers are processed first.`),
|
|
14386
|
+
Status: z.union([z.literal('Active'), z.literal('Deprecated'), z.literal('Disabled')]).describe(`
|
|
14387
|
+
* * Field Name: Status
|
|
14388
|
+
* * Display Name: Status
|
|
14389
|
+
* * SQL Data Type: nvarchar(25)
|
|
14390
|
+
* * Default Value: Active
|
|
14391
|
+
* * Value List Type: List
|
|
14392
|
+
* * Possible Values
|
|
14393
|
+
* * Active
|
|
14394
|
+
* * Deprecated
|
|
14395
|
+
* * Disabled
|
|
14396
|
+
* * Description: Active, Deprecated, or Disabled. Mirrors EntityField status values.`),
|
|
14397
|
+
__mj_CreatedAt: z.date().describe(`
|
|
14398
|
+
* * Field Name: __mj_CreatedAt
|
|
14399
|
+
* * Display Name: Created At
|
|
14400
|
+
* * SQL Data Type: datetimeoffset
|
|
14401
|
+
* * Default Value: getutcdate()`),
|
|
14402
|
+
__mj_UpdatedAt: z.date().describe(`
|
|
14403
|
+
* * Field Name: __mj_UpdatedAt
|
|
14404
|
+
* * Display Name: Updated At
|
|
14405
|
+
* * SQL Data Type: datetimeoffset
|
|
14406
|
+
* * Default Value: getutcdate()`),
|
|
14407
|
+
Integration: z.string().describe(`
|
|
14408
|
+
* * Field Name: Integration
|
|
14409
|
+
* * Display Name: Integration Name
|
|
14410
|
+
* * SQL Data Type: nvarchar(100)`),
|
|
14411
|
+
});
|
|
14412
|
+
/**
|
|
14413
|
+
* zod schema definition for the entity MJ: Integration Source Types
|
|
14414
|
+
*/
|
|
14415
|
+
export const MJIntegrationSourceTypeSchema = z.object({
|
|
14416
|
+
ID: z.string().describe(`
|
|
14417
|
+
* * Field Name: ID
|
|
14418
|
+
* * Display Name: ID
|
|
14419
|
+
* * SQL Data Type: uniqueidentifier
|
|
14420
|
+
* * Default Value: newsequentialid()`),
|
|
14421
|
+
Name: z.string().describe(`
|
|
14422
|
+
* * Field Name: Name
|
|
14423
|
+
* * Display Name: Name
|
|
14424
|
+
* * SQL Data Type: nvarchar(200)
|
|
14425
|
+
* * Description: Display name for this source type (e.g. SaaS API, Relational Database, File Feed).`),
|
|
14426
|
+
Description: z.string().nullable().describe(`
|
|
14427
|
+
* * Field Name: Description
|
|
14428
|
+
* * Display Name: Description
|
|
14429
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
14430
|
+
* * Description: Optional longer description of this source type.`),
|
|
14431
|
+
DriverClass: z.string().describe(`
|
|
14432
|
+
* * Field Name: DriverClass
|
|
14433
|
+
* * Display Name: Driver Class
|
|
14434
|
+
* * SQL Data Type: nvarchar(500)
|
|
14435
|
+
* * Description: Fully-qualified class name registered via @RegisterClass that implements BaseIntegrationConnector for this source type.`),
|
|
14436
|
+
IconClass: z.string().nullable().describe(`
|
|
14437
|
+
* * Field Name: IconClass
|
|
14438
|
+
* * Display Name: Icon Class
|
|
14439
|
+
* * SQL Data Type: nvarchar(200)
|
|
14440
|
+
* * Description: Font Awesome icon class for UI display.`),
|
|
14441
|
+
Status: z.union([z.literal('Active'), z.literal('Inactive')]).describe(`
|
|
14442
|
+
* * Field Name: Status
|
|
14443
|
+
* * Display Name: Status
|
|
14444
|
+
* * SQL Data Type: nvarchar(50)
|
|
14445
|
+
* * Default Value: Active
|
|
14446
|
+
* * Value List Type: List
|
|
14447
|
+
* * Possible Values
|
|
14448
|
+
* * Active
|
|
14449
|
+
* * Inactive
|
|
14450
|
+
* * Description: Whether this source type is available for use. Active or Inactive.`),
|
|
14451
|
+
__mj_CreatedAt: z.date().describe(`
|
|
14452
|
+
* * Field Name: __mj_CreatedAt
|
|
14453
|
+
* * Display Name: Created At
|
|
14454
|
+
* * SQL Data Type: datetimeoffset
|
|
14455
|
+
* * Default Value: getutcdate()`),
|
|
14456
|
+
__mj_UpdatedAt: z.date().describe(`
|
|
14457
|
+
* * Field Name: __mj_UpdatedAt
|
|
14458
|
+
* * Display Name: Updated At
|
|
14459
|
+
* * SQL Data Type: datetimeoffset
|
|
14460
|
+
* * Default Value: getutcdate()`),
|
|
14461
|
+
});
|
|
13791
14462
|
/**
|
|
13792
14463
|
* zod schema definition for the entity MJ: Integration URL Formats
|
|
13793
14464
|
*/
|
|
@@ -13844,9 +14515,11 @@ export const MJIntegrationURLFormatSchema = z.object({
|
|
|
13844
14515
|
export const MJIntegrationSchema = z.object({
|
|
13845
14516
|
Name: z.string().describe(`
|
|
13846
14517
|
* * Field Name: Name
|
|
14518
|
+
* * Display Name: Name
|
|
13847
14519
|
* * SQL Data Type: nvarchar(100)`),
|
|
13848
14520
|
Description: z.string().nullable().describe(`
|
|
13849
14521
|
* * Field Name: Description
|
|
14522
|
+
* * Display Name: Description
|
|
13850
14523
|
* * SQL Data Type: nvarchar(255)`),
|
|
13851
14524
|
NavigationBaseURL: z.string().nullable().describe(`
|
|
13852
14525
|
* * Field Name: NavigationBaseURL
|
|
@@ -13887,8 +14560,19 @@ export const MJIntegrationSchema = z.object({
|
|
|
13887
14560
|
* * Default Value: getutcdate()`),
|
|
13888
14561
|
ID: z.string().describe(`
|
|
13889
14562
|
* * Field Name: ID
|
|
14563
|
+
* * Display Name: ID
|
|
13890
14564
|
* * SQL Data Type: uniqueidentifier
|
|
13891
14565
|
* * Default Value: newsequentialid()`),
|
|
14566
|
+
CredentialTypeID: z.string().nullable().describe(`
|
|
14567
|
+
* * Field Name: CredentialTypeID
|
|
14568
|
+
* * Display Name: Credential Type
|
|
14569
|
+
* * SQL Data Type: uniqueidentifier
|
|
14570
|
+
* * Related Entity/Foreign Key: MJ: Credential Types (vwCredentialTypes.ID)
|
|
14571
|
+
* * Description: Optional link to the credential type required by this integration. Used by the UI to pre-select the credential type when creating new credentials and to filter existing credentials.`),
|
|
14572
|
+
CredentialType: z.string().nullable().describe(`
|
|
14573
|
+
* * Field Name: CredentialType
|
|
14574
|
+
* * Display Name: Credential Type Name
|
|
14575
|
+
* * SQL Data Type: nvarchar(100)`),
|
|
13892
14576
|
});
|
|
13893
14577
|
/**
|
|
13894
14578
|
* zod schema definition for the entity MJ: Libraries
|
|
@@ -41067,25 +41751,25 @@ MJCompanyEntity = __decorate([
|
|
|
41067
41751
|
], MJCompanyEntity);
|
|
41068
41752
|
export { MJCompanyEntity };
|
|
41069
41753
|
/**
|
|
41070
|
-
* MJ: Company Integration
|
|
41754
|
+
* MJ: Company Integration Entity Maps - strongly typed entity sub-class
|
|
41071
41755
|
* * Schema: __mj
|
|
41072
|
-
* * Base Table:
|
|
41073
|
-
* * Base View:
|
|
41074
|
-
* * @description Maps
|
|
41756
|
+
* * Base Table: CompanyIntegrationEntityMap
|
|
41757
|
+
* * Base View: vwCompanyIntegrationEntityMaps
|
|
41758
|
+
* * @description Maps an external object from a company integration to a MemberJunction entity, controlling sync direction, matching, and conflict resolution.
|
|
41075
41759
|
* * Primary Key: ID
|
|
41076
41760
|
* @extends {BaseEntity}
|
|
41077
41761
|
* @class
|
|
41078
41762
|
* @public
|
|
41079
41763
|
*/
|
|
41080
|
-
let
|
|
41764
|
+
let MJCompanyIntegrationEntityMapEntity = class MJCompanyIntegrationEntityMapEntity extends BaseEntity {
|
|
41081
41765
|
/**
|
|
41082
|
-
* Loads the MJ: Company Integration
|
|
41083
|
-
* @param ID: string - primary key value to load the MJ: Company Integration
|
|
41766
|
+
* Loads the MJ: Company Integration Entity Maps record from the database
|
|
41767
|
+
* @param ID: string - primary key value to load the MJ: Company Integration Entity Maps record.
|
|
41084
41768
|
* @param EntityRelationshipsToLoad - (optional) the relationships to load
|
|
41085
41769
|
* @returns {Promise<boolean>} - true if successful, false otherwise
|
|
41086
41770
|
* @public
|
|
41087
41771
|
* @async
|
|
41088
|
-
* @memberof
|
|
41772
|
+
* @memberof MJCompanyIntegrationEntityMapEntity
|
|
41089
41773
|
* @method
|
|
41090
41774
|
* @override
|
|
41091
41775
|
*/
|
|
@@ -41108,7 +41792,7 @@ let MJCompanyIntegrationRecordMapEntity = class MJCompanyIntegrationRecordMapEnt
|
|
|
41108
41792
|
}
|
|
41109
41793
|
/**
|
|
41110
41794
|
* * Field Name: CompanyIntegrationID
|
|
41111
|
-
* * Display Name: Company Integration
|
|
41795
|
+
* * Display Name: Company Integration
|
|
41112
41796
|
* * SQL Data Type: uniqueidentifier
|
|
41113
41797
|
* * Related Entity/Foreign Key: MJ: Company Integrations (vwCompanyIntegrations.ID)
|
|
41114
41798
|
*/
|
|
@@ -41119,20 +41803,32 @@ let MJCompanyIntegrationRecordMapEntity = class MJCompanyIntegrationRecordMapEnt
|
|
|
41119
41803
|
this.Set('CompanyIntegrationID', value);
|
|
41120
41804
|
}
|
|
41121
41805
|
/**
|
|
41122
|
-
* * Field Name:
|
|
41123
|
-
* * Display Name: External
|
|
41124
|
-
* * SQL Data Type: nvarchar(
|
|
41125
|
-
* * Description: The
|
|
41806
|
+
* * Field Name: ExternalObjectName
|
|
41807
|
+
* * Display Name: External Object Name
|
|
41808
|
+
* * SQL Data Type: nvarchar(500)
|
|
41809
|
+
* * Description: The name of the object in the external system (e.g. table name, API resource name).
|
|
41126
41810
|
*/
|
|
41127
|
-
get
|
|
41128
|
-
return this.Get('
|
|
41811
|
+
get ExternalObjectName() {
|
|
41812
|
+
return this.Get('ExternalObjectName');
|
|
41129
41813
|
}
|
|
41130
|
-
set
|
|
41131
|
-
this.Set('
|
|
41814
|
+
set ExternalObjectName(value) {
|
|
41815
|
+
this.Set('ExternalObjectName', value);
|
|
41816
|
+
}
|
|
41817
|
+
/**
|
|
41818
|
+
* * Field Name: ExternalObjectLabel
|
|
41819
|
+
* * Display Name: External Object Label
|
|
41820
|
+
* * SQL Data Type: nvarchar(500)
|
|
41821
|
+
* * Description: Optional human-friendly label for the external object.
|
|
41822
|
+
*/
|
|
41823
|
+
get ExternalObjectLabel() {
|
|
41824
|
+
return this.Get('ExternalObjectLabel');
|
|
41825
|
+
}
|
|
41826
|
+
set ExternalObjectLabel(value) {
|
|
41827
|
+
this.Set('ExternalObjectLabel', value);
|
|
41132
41828
|
}
|
|
41133
41829
|
/**
|
|
41134
41830
|
* * Field Name: EntityID
|
|
41135
|
-
* * Display Name: Entity
|
|
41831
|
+
* * Display Name: Entity
|
|
41136
41832
|
* * SQL Data Type: uniqueidentifier
|
|
41137
41833
|
* * Related Entity/Foreign Key: MJ: Entities (vwEntities.ID)
|
|
41138
41834
|
*/
|
|
@@ -41143,16 +41839,126 @@ let MJCompanyIntegrationRecordMapEntity = class MJCompanyIntegrationRecordMapEnt
|
|
|
41143
41839
|
this.Set('EntityID', value);
|
|
41144
41840
|
}
|
|
41145
41841
|
/**
|
|
41146
|
-
* * Field Name:
|
|
41147
|
-
* * Display Name:
|
|
41148
|
-
* * SQL Data Type: nvarchar(
|
|
41149
|
-
* *
|
|
41842
|
+
* * Field Name: SyncDirection
|
|
41843
|
+
* * Display Name: Sync Direction
|
|
41844
|
+
* * SQL Data Type: nvarchar(50)
|
|
41845
|
+
* * Default Value: Pull
|
|
41846
|
+
* * Value List Type: List
|
|
41847
|
+
* * Possible Values
|
|
41848
|
+
* * Bidirectional
|
|
41849
|
+
* * Pull
|
|
41850
|
+
* * Push
|
|
41851
|
+
* * Description: Whether data flows from external to MJ (Pull), MJ to external (Push), or both.
|
|
41150
41852
|
*/
|
|
41151
|
-
get
|
|
41152
|
-
return this.Get('
|
|
41853
|
+
get SyncDirection() {
|
|
41854
|
+
return this.Get('SyncDirection');
|
|
41153
41855
|
}
|
|
41154
|
-
set
|
|
41155
|
-
this.Set('
|
|
41856
|
+
set SyncDirection(value) {
|
|
41857
|
+
this.Set('SyncDirection', value);
|
|
41858
|
+
}
|
|
41859
|
+
/**
|
|
41860
|
+
* * Field Name: SyncEnabled
|
|
41861
|
+
* * Display Name: Sync Enabled
|
|
41862
|
+
* * SQL Data Type: bit
|
|
41863
|
+
* * Default Value: 1
|
|
41864
|
+
* * Description: When true, this entity map is included in sync runs.
|
|
41865
|
+
*/
|
|
41866
|
+
get SyncEnabled() {
|
|
41867
|
+
return this.Get('SyncEnabled');
|
|
41868
|
+
}
|
|
41869
|
+
set SyncEnabled(value) {
|
|
41870
|
+
this.Set('SyncEnabled', value);
|
|
41871
|
+
}
|
|
41872
|
+
/**
|
|
41873
|
+
* * Field Name: MatchStrategy
|
|
41874
|
+
* * Display Name: Match Strategy
|
|
41875
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
41876
|
+
* * Description: JSON configuration for the match engine describing how to identify existing records (key fields, fuzzy thresholds, etc.).
|
|
41877
|
+
*/
|
|
41878
|
+
get MatchStrategy() {
|
|
41879
|
+
return this.Get('MatchStrategy');
|
|
41880
|
+
}
|
|
41881
|
+
set MatchStrategy(value) {
|
|
41882
|
+
this.Set('MatchStrategy', value);
|
|
41883
|
+
}
|
|
41884
|
+
/**
|
|
41885
|
+
* * Field Name: ConflictResolution
|
|
41886
|
+
* * Display Name: Conflict Resolution
|
|
41887
|
+
* * SQL Data Type: nvarchar(50)
|
|
41888
|
+
* * Default Value: SourceWins
|
|
41889
|
+
* * Value List Type: List
|
|
41890
|
+
* * Possible Values
|
|
41891
|
+
* * DestWins
|
|
41892
|
+
* * Manual
|
|
41893
|
+
* * MostRecent
|
|
41894
|
+
* * SourceWins
|
|
41895
|
+
* * Description: How to handle conflicts when both source and destination have been modified. SourceWins, DestWins, MostRecent, or Manual.
|
|
41896
|
+
*/
|
|
41897
|
+
get ConflictResolution() {
|
|
41898
|
+
return this.Get('ConflictResolution');
|
|
41899
|
+
}
|
|
41900
|
+
set ConflictResolution(value) {
|
|
41901
|
+
this.Set('ConflictResolution', value);
|
|
41902
|
+
}
|
|
41903
|
+
/**
|
|
41904
|
+
* * Field Name: Priority
|
|
41905
|
+
* * Display Name: Priority
|
|
41906
|
+
* * SQL Data Type: int
|
|
41907
|
+
* * Default Value: 0
|
|
41908
|
+
* * Description: Processing order when multiple entity maps exist. Lower numbers are processed first.
|
|
41909
|
+
*/
|
|
41910
|
+
get Priority() {
|
|
41911
|
+
return this.Get('Priority');
|
|
41912
|
+
}
|
|
41913
|
+
set Priority(value) {
|
|
41914
|
+
this.Set('Priority', value);
|
|
41915
|
+
}
|
|
41916
|
+
/**
|
|
41917
|
+
* * Field Name: DeleteBehavior
|
|
41918
|
+
* * Display Name: Delete Behavior
|
|
41919
|
+
* * SQL Data Type: nvarchar(50)
|
|
41920
|
+
* * Default Value: SoftDelete
|
|
41921
|
+
* * Value List Type: List
|
|
41922
|
+
* * Possible Values
|
|
41923
|
+
* * DoNothing
|
|
41924
|
+
* * HardDelete
|
|
41925
|
+
* * SoftDelete
|
|
41926
|
+
* * Description: How to handle records that no longer exist in the source. SoftDelete, DoNothing, or HardDelete.
|
|
41927
|
+
*/
|
|
41928
|
+
get DeleteBehavior() {
|
|
41929
|
+
return this.Get('DeleteBehavior');
|
|
41930
|
+
}
|
|
41931
|
+
set DeleteBehavior(value) {
|
|
41932
|
+
this.Set('DeleteBehavior', value);
|
|
41933
|
+
}
|
|
41934
|
+
/**
|
|
41935
|
+
* * Field Name: Status
|
|
41936
|
+
* * Display Name: Status
|
|
41937
|
+
* * SQL Data Type: nvarchar(50)
|
|
41938
|
+
* * Default Value: Active
|
|
41939
|
+
* * Value List Type: List
|
|
41940
|
+
* * Possible Values
|
|
41941
|
+
* * Active
|
|
41942
|
+
* * Inactive
|
|
41943
|
+
* * Description: Whether this entity map is Active or Inactive.
|
|
41944
|
+
*/
|
|
41945
|
+
get Status() {
|
|
41946
|
+
return this.Get('Status');
|
|
41947
|
+
}
|
|
41948
|
+
set Status(value) {
|
|
41949
|
+
this.Set('Status', value);
|
|
41950
|
+
}
|
|
41951
|
+
/**
|
|
41952
|
+
* * Field Name: Configuration
|
|
41953
|
+
* * Display Name: Configuration
|
|
41954
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
41955
|
+
* * Description: Optional JSON configuration specific to this entity mapping.
|
|
41956
|
+
*/
|
|
41957
|
+
get Configuration() {
|
|
41958
|
+
return this.Get('Configuration');
|
|
41959
|
+
}
|
|
41960
|
+
set Configuration(value) {
|
|
41961
|
+
this.Set('Configuration', value);
|
|
41156
41962
|
}
|
|
41157
41963
|
/**
|
|
41158
41964
|
* * Field Name: __mj_CreatedAt
|
|
@@ -41174,7 +41980,7 @@ let MJCompanyIntegrationRecordMapEntity = class MJCompanyIntegrationRecordMapEnt
|
|
|
41174
41980
|
}
|
|
41175
41981
|
/**
|
|
41176
41982
|
* * Field Name: CompanyIntegration
|
|
41177
|
-
* * Display Name: Company Integration
|
|
41983
|
+
* * Display Name: Company Integration Name
|
|
41178
41984
|
* * SQL Data Type: nvarchar(255)
|
|
41179
41985
|
*/
|
|
41180
41986
|
get CompanyIntegration() {
|
|
@@ -41182,37 +41988,37 @@ let MJCompanyIntegrationRecordMapEntity = class MJCompanyIntegrationRecordMapEnt
|
|
|
41182
41988
|
}
|
|
41183
41989
|
/**
|
|
41184
41990
|
* * Field Name: Entity
|
|
41185
|
-
* * Display Name: Entity
|
|
41991
|
+
* * Display Name: Entity Name
|
|
41186
41992
|
* * SQL Data Type: nvarchar(255)
|
|
41187
41993
|
*/
|
|
41188
41994
|
get Entity() {
|
|
41189
41995
|
return this.Get('Entity');
|
|
41190
41996
|
}
|
|
41191
41997
|
};
|
|
41192
|
-
|
|
41193
|
-
RegisterClass(BaseEntity, 'MJ: Company Integration
|
|
41194
|
-
],
|
|
41195
|
-
export {
|
|
41998
|
+
MJCompanyIntegrationEntityMapEntity = __decorate([
|
|
41999
|
+
RegisterClass(BaseEntity, 'MJ: Company Integration Entity Maps')
|
|
42000
|
+
], MJCompanyIntegrationEntityMapEntity);
|
|
42001
|
+
export { MJCompanyIntegrationEntityMapEntity };
|
|
41196
42002
|
/**
|
|
41197
|
-
* MJ: Company Integration
|
|
42003
|
+
* MJ: Company Integration Field Maps - strongly typed entity sub-class
|
|
41198
42004
|
* * Schema: __mj
|
|
41199
|
-
* * Base Table:
|
|
41200
|
-
* * Base View:
|
|
41201
|
-
* * @description
|
|
42005
|
+
* * Base Table: CompanyIntegrationFieldMap
|
|
42006
|
+
* * Base View: vwCompanyIntegrationFieldMaps
|
|
42007
|
+
* * @description Maps individual fields between an external source object and a MemberJunction entity, with optional transform pipeline.
|
|
41202
42008
|
* * Primary Key: ID
|
|
41203
42009
|
* @extends {BaseEntity}
|
|
41204
42010
|
* @class
|
|
41205
42011
|
* @public
|
|
41206
42012
|
*/
|
|
41207
|
-
let
|
|
42013
|
+
let MJCompanyIntegrationFieldMapEntity = class MJCompanyIntegrationFieldMapEntity extends BaseEntity {
|
|
41208
42014
|
/**
|
|
41209
|
-
* Loads the MJ: Company Integration
|
|
41210
|
-
* @param ID: string - primary key value to load the MJ: Company Integration
|
|
42015
|
+
* Loads the MJ: Company Integration Field Maps record from the database
|
|
42016
|
+
* @param ID: string - primary key value to load the MJ: Company Integration Field Maps record.
|
|
41211
42017
|
* @param EntityRelationshipsToLoad - (optional) the relationships to load
|
|
41212
42018
|
* @returns {Promise<boolean>} - true if successful, false otherwise
|
|
41213
42019
|
* @public
|
|
41214
42020
|
* @async
|
|
41215
|
-
* @memberof
|
|
42021
|
+
* @memberof MJCompanyIntegrationFieldMapEntity
|
|
41216
42022
|
* @method
|
|
41217
42023
|
* @override
|
|
41218
42024
|
*/
|
|
@@ -41234,87 +42040,162 @@ let MJCompanyIntegrationRunAPILogEntity = class MJCompanyIntegrationRunAPILogEnt
|
|
|
41234
42040
|
this.Set('ID', value);
|
|
41235
42041
|
}
|
|
41236
42042
|
/**
|
|
41237
|
-
* * Field Name:
|
|
41238
|
-
* * Display Name:
|
|
42043
|
+
* * Field Name: EntityMapID
|
|
42044
|
+
* * Display Name: Entity Map ID
|
|
41239
42045
|
* * SQL Data Type: uniqueidentifier
|
|
41240
|
-
* * Related Entity/Foreign Key: MJ: Company Integration
|
|
42046
|
+
* * Related Entity/Foreign Key: MJ: Company Integration Entity Maps (vwCompanyIntegrationEntityMaps.ID)
|
|
41241
42047
|
*/
|
|
41242
|
-
get
|
|
41243
|
-
return this.Get('
|
|
42048
|
+
get EntityMapID() {
|
|
42049
|
+
return this.Get('EntityMapID');
|
|
41244
42050
|
}
|
|
41245
|
-
set
|
|
41246
|
-
this.Set('
|
|
42051
|
+
set EntityMapID(value) {
|
|
42052
|
+
this.Set('EntityMapID', value);
|
|
41247
42053
|
}
|
|
41248
42054
|
/**
|
|
41249
|
-
* * Field Name:
|
|
41250
|
-
* * Display Name:
|
|
41251
|
-
* * SQL Data Type:
|
|
41252
|
-
* *
|
|
41253
|
-
* * Description: Timestamp when this API call was executed during the integration run.
|
|
42055
|
+
* * Field Name: SourceFieldName
|
|
42056
|
+
* * Display Name: Source Field Name
|
|
42057
|
+
* * SQL Data Type: nvarchar(500)
|
|
42058
|
+
* * Description: The field/column name in the external source system.
|
|
41254
42059
|
*/
|
|
41255
|
-
get
|
|
41256
|
-
return this.Get('
|
|
42060
|
+
get SourceFieldName() {
|
|
42061
|
+
return this.Get('SourceFieldName');
|
|
41257
42062
|
}
|
|
41258
|
-
set
|
|
41259
|
-
this.Set('
|
|
42063
|
+
set SourceFieldName(value) {
|
|
42064
|
+
this.Set('SourceFieldName', value);
|
|
41260
42065
|
}
|
|
41261
42066
|
/**
|
|
41262
|
-
* * Field Name:
|
|
41263
|
-
* * Display Name:
|
|
41264
|
-
* * SQL Data Type:
|
|
41265
|
-
* *
|
|
41266
|
-
* * Description: Indicates whether the API call completed successfully or encountered an error.
|
|
42067
|
+
* * Field Name: SourceFieldLabel
|
|
42068
|
+
* * Display Name: Source Field Label
|
|
42069
|
+
* * SQL Data Type: nvarchar(500)
|
|
42070
|
+
* * Description: Optional human-friendly label for the source field.
|
|
41267
42071
|
*/
|
|
41268
|
-
get
|
|
41269
|
-
return this.Get('
|
|
42072
|
+
get SourceFieldLabel() {
|
|
42073
|
+
return this.Get('SourceFieldLabel');
|
|
41270
42074
|
}
|
|
41271
|
-
set
|
|
41272
|
-
this.Set('
|
|
42075
|
+
set SourceFieldLabel(value) {
|
|
42076
|
+
this.Set('SourceFieldLabel', value);
|
|
41273
42077
|
}
|
|
41274
42078
|
/**
|
|
41275
|
-
* * Field Name:
|
|
41276
|
-
* * Display Name:
|
|
41277
|
-
* * SQL Data Type: nvarchar(
|
|
42079
|
+
* * Field Name: DestinationFieldName
|
|
42080
|
+
* * Display Name: Destination Field Name
|
|
42081
|
+
* * SQL Data Type: nvarchar(500)
|
|
42082
|
+
* * Description: The MJ entity field name this source field maps to.
|
|
42083
|
+
*/
|
|
42084
|
+
get DestinationFieldName() {
|
|
42085
|
+
return this.Get('DestinationFieldName');
|
|
42086
|
+
}
|
|
42087
|
+
set DestinationFieldName(value) {
|
|
42088
|
+
this.Set('DestinationFieldName', value);
|
|
42089
|
+
}
|
|
42090
|
+
/**
|
|
42091
|
+
* * Field Name: DestinationFieldLabel
|
|
42092
|
+
* * Display Name: Destination Field Label
|
|
42093
|
+
* * SQL Data Type: nvarchar(500)
|
|
42094
|
+
* * Description: Optional human-friendly label for the destination field.
|
|
42095
|
+
*/
|
|
42096
|
+
get DestinationFieldLabel() {
|
|
42097
|
+
return this.Get('DestinationFieldLabel');
|
|
42098
|
+
}
|
|
42099
|
+
set DestinationFieldLabel(value) {
|
|
42100
|
+
this.Set('DestinationFieldLabel', value);
|
|
42101
|
+
}
|
|
42102
|
+
/**
|
|
42103
|
+
* * Field Name: Direction
|
|
42104
|
+
* * Display Name: Direction
|
|
42105
|
+
* * SQL Data Type: nvarchar(50)
|
|
42106
|
+
* * Default Value: SourceToDest
|
|
41278
42107
|
* * Value List Type: List
|
|
41279
42108
|
* * Possible Values
|
|
41280
|
-
* *
|
|
41281
|
-
* *
|
|
41282
|
-
* *
|
|
41283
|
-
*
|
|
41284
|
-
* * PATCH
|
|
41285
|
-
* * POST
|
|
41286
|
-
* * PUT
|
|
41287
|
-
* * Description: HTTP method used for the API call (GET, POST, PUT, DELETE, PATCH).
|
|
42109
|
+
* * Both
|
|
42110
|
+
* * DestToSource
|
|
42111
|
+
* * SourceToDest
|
|
42112
|
+
* * Description: Direction of field mapping: SourceToDest, DestToSource, or Both.
|
|
41288
42113
|
*/
|
|
41289
|
-
get
|
|
41290
|
-
return this.Get('
|
|
42114
|
+
get Direction() {
|
|
42115
|
+
return this.Get('Direction');
|
|
41291
42116
|
}
|
|
41292
|
-
set
|
|
41293
|
-
this.Set('
|
|
42117
|
+
set Direction(value) {
|
|
42118
|
+
this.Set('Direction', value);
|
|
41294
42119
|
}
|
|
41295
42120
|
/**
|
|
41296
|
-
* * Field Name:
|
|
41297
|
-
* * Display Name:
|
|
42121
|
+
* * Field Name: TransformPipeline
|
|
42122
|
+
* * Display Name: Transform Pipeline
|
|
41298
42123
|
* * SQL Data Type: nvarchar(MAX)
|
|
41299
|
-
* * Description:
|
|
42124
|
+
* * Description: JSON array of transform names to apply in order (e.g. ["trim", "uppercase"]). See FieldMappingEngine for available transforms.
|
|
41300
42125
|
*/
|
|
41301
|
-
get
|
|
41302
|
-
return this.Get('
|
|
42126
|
+
get TransformPipeline() {
|
|
42127
|
+
return this.Get('TransformPipeline');
|
|
41303
42128
|
}
|
|
41304
|
-
set
|
|
41305
|
-
this.Set('
|
|
42129
|
+
set TransformPipeline(value) {
|
|
42130
|
+
this.Set('TransformPipeline', value);
|
|
41306
42131
|
}
|
|
41307
42132
|
/**
|
|
41308
|
-
* * Field Name:
|
|
41309
|
-
* * Display Name:
|
|
42133
|
+
* * Field Name: IsKeyField
|
|
42134
|
+
* * Display Name: Is Key Field
|
|
42135
|
+
* * SQL Data Type: bit
|
|
42136
|
+
* * Default Value: 0
|
|
42137
|
+
* * Description: When true, this field is used by the MatchEngine to find existing records during sync.
|
|
42138
|
+
*/
|
|
42139
|
+
get IsKeyField() {
|
|
42140
|
+
return this.Get('IsKeyField');
|
|
42141
|
+
}
|
|
42142
|
+
set IsKeyField(value) {
|
|
42143
|
+
this.Set('IsKeyField', value);
|
|
42144
|
+
}
|
|
42145
|
+
/**
|
|
42146
|
+
* * Field Name: IsRequired
|
|
42147
|
+
* * Display Name: Is Required
|
|
42148
|
+
* * SQL Data Type: bit
|
|
42149
|
+
* * Default Value: 0
|
|
42150
|
+
* * Description: When true, a sync record is rejected if this field has no value.
|
|
42151
|
+
*/
|
|
42152
|
+
get IsRequired() {
|
|
42153
|
+
return this.Get('IsRequired');
|
|
42154
|
+
}
|
|
42155
|
+
set IsRequired(value) {
|
|
42156
|
+
this.Set('IsRequired', value);
|
|
42157
|
+
}
|
|
42158
|
+
/**
|
|
42159
|
+
* * Field Name: DefaultValue
|
|
42160
|
+
* * Display Name: Default Value
|
|
41310
42161
|
* * SQL Data Type: nvarchar(MAX)
|
|
41311
|
-
* * Description:
|
|
42162
|
+
* * Description: Default value to use when the source field is null or missing.
|
|
41312
42163
|
*/
|
|
41313
|
-
get
|
|
41314
|
-
return this.Get('
|
|
42164
|
+
get DefaultValue() {
|
|
42165
|
+
return this.Get('DefaultValue');
|
|
41315
42166
|
}
|
|
41316
|
-
set
|
|
41317
|
-
this.Set('
|
|
42167
|
+
set DefaultValue(value) {
|
|
42168
|
+
this.Set('DefaultValue', value);
|
|
42169
|
+
}
|
|
42170
|
+
/**
|
|
42171
|
+
* * Field Name: Priority
|
|
42172
|
+
* * Display Name: Priority
|
|
42173
|
+
* * SQL Data Type: int
|
|
42174
|
+
* * Default Value: 0
|
|
42175
|
+
* * Description: Processing order for this field mapping within the entity map.
|
|
42176
|
+
*/
|
|
42177
|
+
get Priority() {
|
|
42178
|
+
return this.Get('Priority');
|
|
42179
|
+
}
|
|
42180
|
+
set Priority(value) {
|
|
42181
|
+
this.Set('Priority', value);
|
|
42182
|
+
}
|
|
42183
|
+
/**
|
|
42184
|
+
* * Field Name: Status
|
|
42185
|
+
* * Display Name: Status
|
|
42186
|
+
* * SQL Data Type: nvarchar(50)
|
|
42187
|
+
* * Default Value: Active
|
|
42188
|
+
* * Value List Type: List
|
|
42189
|
+
* * Possible Values
|
|
42190
|
+
* * Active
|
|
42191
|
+
* * Inactive
|
|
42192
|
+
* * Description: Whether this field mapping is Active or Inactive.
|
|
42193
|
+
*/
|
|
42194
|
+
get Status() {
|
|
42195
|
+
return this.Get('Status');
|
|
42196
|
+
}
|
|
42197
|
+
set Status(value) {
|
|
42198
|
+
this.Set('Status', value);
|
|
41318
42199
|
}
|
|
41319
42200
|
/**
|
|
41320
42201
|
* * Field Name: __mj_CreatedAt
|
|
@@ -41335,38 +42216,319 @@ let MJCompanyIntegrationRunAPILogEntity = class MJCompanyIntegrationRunAPILogEnt
|
|
|
41335
42216
|
return this.Get('__mj_UpdatedAt');
|
|
41336
42217
|
}
|
|
41337
42218
|
/**
|
|
41338
|
-
* * Field Name:
|
|
41339
|
-
* * Display Name:
|
|
41340
|
-
* * SQL Data Type: nvarchar(
|
|
42219
|
+
* * Field Name: EntityMap
|
|
42220
|
+
* * Display Name: Entity Map
|
|
42221
|
+
* * SQL Data Type: nvarchar(500)
|
|
41341
42222
|
*/
|
|
41342
|
-
get
|
|
41343
|
-
return this.Get('
|
|
42223
|
+
get EntityMap() {
|
|
42224
|
+
return this.Get('EntityMap');
|
|
41344
42225
|
}
|
|
41345
42226
|
};
|
|
41346
|
-
|
|
41347
|
-
RegisterClass(BaseEntity, 'MJ: Company Integration
|
|
41348
|
-
],
|
|
41349
|
-
export {
|
|
42227
|
+
MJCompanyIntegrationFieldMapEntity = __decorate([
|
|
42228
|
+
RegisterClass(BaseEntity, 'MJ: Company Integration Field Maps')
|
|
42229
|
+
], MJCompanyIntegrationFieldMapEntity);
|
|
42230
|
+
export { MJCompanyIntegrationFieldMapEntity };
|
|
41350
42231
|
/**
|
|
41351
|
-
* MJ: Company Integration
|
|
42232
|
+
* MJ: Company Integration Record Maps - strongly typed entity sub-class
|
|
41352
42233
|
* * Schema: __mj
|
|
41353
|
-
* * Base Table:
|
|
41354
|
-
* * Base View:
|
|
41355
|
-
* * @description
|
|
42234
|
+
* * Base Table: CompanyIntegrationRecordMap
|
|
42235
|
+
* * Base View: vwCompanyIntegrationRecordMaps
|
|
42236
|
+
* * @description Maps records between internal entities and external system identifiers, maintaining synchronization between MemberJunction and integrated platforms.
|
|
41356
42237
|
* * Primary Key: ID
|
|
41357
42238
|
* @extends {BaseEntity}
|
|
41358
42239
|
* @class
|
|
41359
42240
|
* @public
|
|
41360
42241
|
*/
|
|
41361
|
-
let
|
|
42242
|
+
let MJCompanyIntegrationRecordMapEntity = class MJCompanyIntegrationRecordMapEntity extends BaseEntity {
|
|
41362
42243
|
/**
|
|
41363
|
-
* Loads the MJ: Company Integration
|
|
41364
|
-
* @param ID: string - primary key value to load the MJ: Company Integration
|
|
42244
|
+
* Loads the MJ: Company Integration Record Maps record from the database
|
|
42245
|
+
* @param ID: string - primary key value to load the MJ: Company Integration Record Maps record.
|
|
41365
42246
|
* @param EntityRelationshipsToLoad - (optional) the relationships to load
|
|
41366
42247
|
* @returns {Promise<boolean>} - true if successful, false otherwise
|
|
41367
42248
|
* @public
|
|
41368
42249
|
* @async
|
|
41369
|
-
* @memberof
|
|
42250
|
+
* @memberof MJCompanyIntegrationRecordMapEntity
|
|
42251
|
+
* @method
|
|
42252
|
+
* @override
|
|
42253
|
+
*/
|
|
42254
|
+
async Load(ID, EntityRelationshipsToLoad) {
|
|
42255
|
+
const compositeKey = new CompositeKey();
|
|
42256
|
+
compositeKey.KeyValuePairs.push({ FieldName: 'ID', Value: ID });
|
|
42257
|
+
return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
|
|
42258
|
+
}
|
|
42259
|
+
/**
|
|
42260
|
+
* * Field Name: ID
|
|
42261
|
+
* * Display Name: ID
|
|
42262
|
+
* * SQL Data Type: uniqueidentifier
|
|
42263
|
+
* * Default Value: newsequentialid()
|
|
42264
|
+
*/
|
|
42265
|
+
get ID() {
|
|
42266
|
+
return this.Get('ID');
|
|
42267
|
+
}
|
|
42268
|
+
set ID(value) {
|
|
42269
|
+
this.Set('ID', value);
|
|
42270
|
+
}
|
|
42271
|
+
/**
|
|
42272
|
+
* * Field Name: CompanyIntegrationID
|
|
42273
|
+
* * Display Name: Company Integration ID
|
|
42274
|
+
* * SQL Data Type: uniqueidentifier
|
|
42275
|
+
* * Related Entity/Foreign Key: MJ: Company Integrations (vwCompanyIntegrations.ID)
|
|
42276
|
+
*/
|
|
42277
|
+
get CompanyIntegrationID() {
|
|
42278
|
+
return this.Get('CompanyIntegrationID');
|
|
42279
|
+
}
|
|
42280
|
+
set CompanyIntegrationID(value) {
|
|
42281
|
+
this.Set('CompanyIntegrationID', value);
|
|
42282
|
+
}
|
|
42283
|
+
/**
|
|
42284
|
+
* * Field Name: ExternalSystemRecordID
|
|
42285
|
+
* * Display Name: External System Record ID
|
|
42286
|
+
* * SQL Data Type: nvarchar(750)
|
|
42287
|
+
* * Description: The unique identifier for this record in the external integrated system.
|
|
42288
|
+
*/
|
|
42289
|
+
get ExternalSystemRecordID() {
|
|
42290
|
+
return this.Get('ExternalSystemRecordID');
|
|
42291
|
+
}
|
|
42292
|
+
set ExternalSystemRecordID(value) {
|
|
42293
|
+
this.Set('ExternalSystemRecordID', value);
|
|
42294
|
+
}
|
|
42295
|
+
/**
|
|
42296
|
+
* * Field Name: EntityID
|
|
42297
|
+
* * Display Name: Entity ID
|
|
42298
|
+
* * SQL Data Type: uniqueidentifier
|
|
42299
|
+
* * Related Entity/Foreign Key: MJ: Entities (vwEntities.ID)
|
|
42300
|
+
*/
|
|
42301
|
+
get EntityID() {
|
|
42302
|
+
return this.Get('EntityID');
|
|
42303
|
+
}
|
|
42304
|
+
set EntityID(value) {
|
|
42305
|
+
this.Set('EntityID', value);
|
|
42306
|
+
}
|
|
42307
|
+
/**
|
|
42308
|
+
* * Field Name: EntityRecordID
|
|
42309
|
+
* * Display Name: Entity Record ID
|
|
42310
|
+
* * SQL Data Type: nvarchar(750)
|
|
42311
|
+
* * Description: The internal MemberJunction record ID that corresponds to the external system record.
|
|
42312
|
+
*/
|
|
42313
|
+
get EntityRecordID() {
|
|
42314
|
+
return this.Get('EntityRecordID');
|
|
42315
|
+
}
|
|
42316
|
+
set EntityRecordID(value) {
|
|
42317
|
+
this.Set('EntityRecordID', value);
|
|
42318
|
+
}
|
|
42319
|
+
/**
|
|
42320
|
+
* * Field Name: __mj_CreatedAt
|
|
42321
|
+
* * Display Name: Created At
|
|
42322
|
+
* * SQL Data Type: datetimeoffset
|
|
42323
|
+
* * Default Value: getutcdate()
|
|
42324
|
+
*/
|
|
42325
|
+
get __mj_CreatedAt() {
|
|
42326
|
+
return this.Get('__mj_CreatedAt');
|
|
42327
|
+
}
|
|
42328
|
+
/**
|
|
42329
|
+
* * Field Name: __mj_UpdatedAt
|
|
42330
|
+
* * Display Name: Updated At
|
|
42331
|
+
* * SQL Data Type: datetimeoffset
|
|
42332
|
+
* * Default Value: getutcdate()
|
|
42333
|
+
*/
|
|
42334
|
+
get __mj_UpdatedAt() {
|
|
42335
|
+
return this.Get('__mj_UpdatedAt');
|
|
42336
|
+
}
|
|
42337
|
+
/**
|
|
42338
|
+
* * Field Name: CompanyIntegration
|
|
42339
|
+
* * Display Name: Company Integration
|
|
42340
|
+
* * SQL Data Type: nvarchar(255)
|
|
42341
|
+
*/
|
|
42342
|
+
get CompanyIntegration() {
|
|
42343
|
+
return this.Get('CompanyIntegration');
|
|
42344
|
+
}
|
|
42345
|
+
/**
|
|
42346
|
+
* * Field Name: Entity
|
|
42347
|
+
* * Display Name: Entity
|
|
42348
|
+
* * SQL Data Type: nvarchar(255)
|
|
42349
|
+
*/
|
|
42350
|
+
get Entity() {
|
|
42351
|
+
return this.Get('Entity');
|
|
42352
|
+
}
|
|
42353
|
+
};
|
|
42354
|
+
MJCompanyIntegrationRecordMapEntity = __decorate([
|
|
42355
|
+
RegisterClass(BaseEntity, 'MJ: Company Integration Record Maps')
|
|
42356
|
+
], MJCompanyIntegrationRecordMapEntity);
|
|
42357
|
+
export { MJCompanyIntegrationRecordMapEntity };
|
|
42358
|
+
/**
|
|
42359
|
+
* MJ: Company Integration Run API Logs - strongly typed entity sub-class
|
|
42360
|
+
* * Schema: __mj
|
|
42361
|
+
* * Base Table: CompanyIntegrationRunAPILog
|
|
42362
|
+
* * Base View: vwCompanyIntegrationRunAPILogs
|
|
42363
|
+
* * @description Logs detailed API calls and responses during integration runs, including request/response payloads, status codes, and timing information.
|
|
42364
|
+
* * Primary Key: ID
|
|
42365
|
+
* @extends {BaseEntity}
|
|
42366
|
+
* @class
|
|
42367
|
+
* @public
|
|
42368
|
+
*/
|
|
42369
|
+
let MJCompanyIntegrationRunAPILogEntity = class MJCompanyIntegrationRunAPILogEntity extends BaseEntity {
|
|
42370
|
+
/**
|
|
42371
|
+
* Loads the MJ: Company Integration Run API Logs record from the database
|
|
42372
|
+
* @param ID: string - primary key value to load the MJ: Company Integration Run API Logs record.
|
|
42373
|
+
* @param EntityRelationshipsToLoad - (optional) the relationships to load
|
|
42374
|
+
* @returns {Promise<boolean>} - true if successful, false otherwise
|
|
42375
|
+
* @public
|
|
42376
|
+
* @async
|
|
42377
|
+
* @memberof MJCompanyIntegrationRunAPILogEntity
|
|
42378
|
+
* @method
|
|
42379
|
+
* @override
|
|
42380
|
+
*/
|
|
42381
|
+
async Load(ID, EntityRelationshipsToLoad) {
|
|
42382
|
+
const compositeKey = new CompositeKey();
|
|
42383
|
+
compositeKey.KeyValuePairs.push({ FieldName: 'ID', Value: ID });
|
|
42384
|
+
return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
|
|
42385
|
+
}
|
|
42386
|
+
/**
|
|
42387
|
+
* * Field Name: ID
|
|
42388
|
+
* * Display Name: ID
|
|
42389
|
+
* * SQL Data Type: uniqueidentifier
|
|
42390
|
+
* * Default Value: newsequentialid()
|
|
42391
|
+
*/
|
|
42392
|
+
get ID() {
|
|
42393
|
+
return this.Get('ID');
|
|
42394
|
+
}
|
|
42395
|
+
set ID(value) {
|
|
42396
|
+
this.Set('ID', value);
|
|
42397
|
+
}
|
|
42398
|
+
/**
|
|
42399
|
+
* * Field Name: CompanyIntegrationRunID
|
|
42400
|
+
* * Display Name: Company Integration Run
|
|
42401
|
+
* * SQL Data Type: uniqueidentifier
|
|
42402
|
+
* * Related Entity/Foreign Key: MJ: Company Integration Runs (vwCompanyIntegrationRuns.ID)
|
|
42403
|
+
*/
|
|
42404
|
+
get CompanyIntegrationRunID() {
|
|
42405
|
+
return this.Get('CompanyIntegrationRunID');
|
|
42406
|
+
}
|
|
42407
|
+
set CompanyIntegrationRunID(value) {
|
|
42408
|
+
this.Set('CompanyIntegrationRunID', value);
|
|
42409
|
+
}
|
|
42410
|
+
/**
|
|
42411
|
+
* * Field Name: ExecutedAt
|
|
42412
|
+
* * Display Name: Executed At
|
|
42413
|
+
* * SQL Data Type: datetimeoffset
|
|
42414
|
+
* * Default Value: sysdatetimeoffset()
|
|
42415
|
+
* * Description: Timestamp when this API call was executed during the integration run.
|
|
42416
|
+
*/
|
|
42417
|
+
get ExecutedAt() {
|
|
42418
|
+
return this.Get('ExecutedAt');
|
|
42419
|
+
}
|
|
42420
|
+
set ExecutedAt(value) {
|
|
42421
|
+
this.Set('ExecutedAt', value);
|
|
42422
|
+
}
|
|
42423
|
+
/**
|
|
42424
|
+
* * Field Name: IsSuccess
|
|
42425
|
+
* * Display Name: Success
|
|
42426
|
+
* * SQL Data Type: bit
|
|
42427
|
+
* * Default Value: 0
|
|
42428
|
+
* * Description: Indicates whether the API call completed successfully or encountered an error.
|
|
42429
|
+
*/
|
|
42430
|
+
get IsSuccess() {
|
|
42431
|
+
return this.Get('IsSuccess');
|
|
42432
|
+
}
|
|
42433
|
+
set IsSuccess(value) {
|
|
42434
|
+
this.Set('IsSuccess', value);
|
|
42435
|
+
}
|
|
42436
|
+
/**
|
|
42437
|
+
* * Field Name: RequestMethod
|
|
42438
|
+
* * Display Name: Request Method
|
|
42439
|
+
* * SQL Data Type: nvarchar(12)
|
|
42440
|
+
* * Value List Type: List
|
|
42441
|
+
* * Possible Values
|
|
42442
|
+
* * DELETE
|
|
42443
|
+
* * GET
|
|
42444
|
+
* * HEAD
|
|
42445
|
+
* * OPTIONS
|
|
42446
|
+
* * PATCH
|
|
42447
|
+
* * POST
|
|
42448
|
+
* * PUT
|
|
42449
|
+
* * Description: HTTP method used for the API call (GET, POST, PUT, DELETE, PATCH).
|
|
42450
|
+
*/
|
|
42451
|
+
get RequestMethod() {
|
|
42452
|
+
return this.Get('RequestMethod');
|
|
42453
|
+
}
|
|
42454
|
+
set RequestMethod(value) {
|
|
42455
|
+
this.Set('RequestMethod', value);
|
|
42456
|
+
}
|
|
42457
|
+
/**
|
|
42458
|
+
* * Field Name: URL
|
|
42459
|
+
* * Display Name: URL
|
|
42460
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
42461
|
+
* * Description: The complete URL that was called, including query parameters.
|
|
42462
|
+
*/
|
|
42463
|
+
get URL() {
|
|
42464
|
+
return this.Get('URL');
|
|
42465
|
+
}
|
|
42466
|
+
set URL(value) {
|
|
42467
|
+
this.Set('URL', value);
|
|
42468
|
+
}
|
|
42469
|
+
/**
|
|
42470
|
+
* * Field Name: Parameters
|
|
42471
|
+
* * Display Name: Parameters
|
|
42472
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
42473
|
+
* * Description: JSON-formatted request body or parameters sent with the API call.
|
|
42474
|
+
*/
|
|
42475
|
+
get Parameters() {
|
|
42476
|
+
return this.Get('Parameters');
|
|
42477
|
+
}
|
|
42478
|
+
set Parameters(value) {
|
|
42479
|
+
this.Set('Parameters', value);
|
|
42480
|
+
}
|
|
42481
|
+
/**
|
|
42482
|
+
* * Field Name: __mj_CreatedAt
|
|
42483
|
+
* * Display Name: Created At
|
|
42484
|
+
* * SQL Data Type: datetimeoffset
|
|
42485
|
+
* * Default Value: getutcdate()
|
|
42486
|
+
*/
|
|
42487
|
+
get __mj_CreatedAt() {
|
|
42488
|
+
return this.Get('__mj_CreatedAt');
|
|
42489
|
+
}
|
|
42490
|
+
/**
|
|
42491
|
+
* * Field Name: __mj_UpdatedAt
|
|
42492
|
+
* * Display Name: Updated At
|
|
42493
|
+
* * SQL Data Type: datetimeoffset
|
|
42494
|
+
* * Default Value: getutcdate()
|
|
42495
|
+
*/
|
|
42496
|
+
get __mj_UpdatedAt() {
|
|
42497
|
+
return this.Get('__mj_UpdatedAt');
|
|
42498
|
+
}
|
|
42499
|
+
/**
|
|
42500
|
+
* * Field Name: CompanyIntegrationRun
|
|
42501
|
+
* * Display Name: Company Integration Run
|
|
42502
|
+
* * SQL Data Type: nvarchar(100)
|
|
42503
|
+
*/
|
|
42504
|
+
get CompanyIntegrationRun() {
|
|
42505
|
+
return this.Get('CompanyIntegrationRun');
|
|
42506
|
+
}
|
|
42507
|
+
};
|
|
42508
|
+
MJCompanyIntegrationRunAPILogEntity = __decorate([
|
|
42509
|
+
RegisterClass(BaseEntity, 'MJ: Company Integration Run API Logs')
|
|
42510
|
+
], MJCompanyIntegrationRunAPILogEntity);
|
|
42511
|
+
export { MJCompanyIntegrationRunAPILogEntity };
|
|
42512
|
+
/**
|
|
42513
|
+
* MJ: Company Integration Run Details - strongly typed entity sub-class
|
|
42514
|
+
* * Schema: __mj
|
|
42515
|
+
* * Base Table: CompanyIntegrationRunDetail
|
|
42516
|
+
* * Base View: vwCompanyIntegrationRunDetails
|
|
42517
|
+
* * @description Tracks individual record-level operations within an integration run, including success/failure status and error details for each processed item.
|
|
42518
|
+
* * Primary Key: ID
|
|
42519
|
+
* @extends {BaseEntity}
|
|
42520
|
+
* @class
|
|
42521
|
+
* @public
|
|
42522
|
+
*/
|
|
42523
|
+
let MJCompanyIntegrationRunDetailEntity = class MJCompanyIntegrationRunDetailEntity extends BaseEntity {
|
|
42524
|
+
/**
|
|
42525
|
+
* Loads the MJ: Company Integration Run Details record from the database
|
|
42526
|
+
* @param ID: string - primary key value to load the MJ: Company Integration Run Details record.
|
|
42527
|
+
* @param EntityRelationshipsToLoad - (optional) the relationships to load
|
|
42528
|
+
* @returns {Promise<boolean>} - true if successful, false otherwise
|
|
42529
|
+
* @public
|
|
42530
|
+
* @async
|
|
42531
|
+
* @memberof MJCompanyIntegrationRunDetailEntity
|
|
41370
42532
|
* @method
|
|
41371
42533
|
* @override
|
|
41372
42534
|
*/
|
|
@@ -41707,6 +42869,162 @@ MJCompanyIntegrationRunEntity = __decorate([
|
|
|
41707
42869
|
RegisterClass(BaseEntity, 'MJ: Company Integration Runs')
|
|
41708
42870
|
], MJCompanyIntegrationRunEntity);
|
|
41709
42871
|
export { MJCompanyIntegrationRunEntity };
|
|
42872
|
+
/**
|
|
42873
|
+
* MJ: Company Integration Sync Watermarks - strongly typed entity sub-class
|
|
42874
|
+
* * Schema: __mj
|
|
42875
|
+
* * Base Table: CompanyIntegrationSyncWatermark
|
|
42876
|
+
* * Base View: vwCompanyIntegrationSyncWatermarks
|
|
42877
|
+
* * @description Tracks incremental sync progress per entity map and direction using watermarks (timestamp, cursor, change token, or version).
|
|
42878
|
+
* * Primary Key: ID
|
|
42879
|
+
* @extends {BaseEntity}
|
|
42880
|
+
* @class
|
|
42881
|
+
* @public
|
|
42882
|
+
*/
|
|
42883
|
+
let MJCompanyIntegrationSyncWatermarkEntity = class MJCompanyIntegrationSyncWatermarkEntity extends BaseEntity {
|
|
42884
|
+
/**
|
|
42885
|
+
* Loads the MJ: Company Integration Sync Watermarks record from the database
|
|
42886
|
+
* @param ID: string - primary key value to load the MJ: Company Integration Sync Watermarks record.
|
|
42887
|
+
* @param EntityRelationshipsToLoad - (optional) the relationships to load
|
|
42888
|
+
* @returns {Promise<boolean>} - true if successful, false otherwise
|
|
42889
|
+
* @public
|
|
42890
|
+
* @async
|
|
42891
|
+
* @memberof MJCompanyIntegrationSyncWatermarkEntity
|
|
42892
|
+
* @method
|
|
42893
|
+
* @override
|
|
42894
|
+
*/
|
|
42895
|
+
async Load(ID, EntityRelationshipsToLoad) {
|
|
42896
|
+
const compositeKey = new CompositeKey();
|
|
42897
|
+
compositeKey.KeyValuePairs.push({ FieldName: 'ID', Value: ID });
|
|
42898
|
+
return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
|
|
42899
|
+
}
|
|
42900
|
+
/**
|
|
42901
|
+
* * Field Name: ID
|
|
42902
|
+
* * Display Name: ID
|
|
42903
|
+
* * SQL Data Type: uniqueidentifier
|
|
42904
|
+
* * Default Value: newsequentialid()
|
|
42905
|
+
*/
|
|
42906
|
+
get ID() {
|
|
42907
|
+
return this.Get('ID');
|
|
42908
|
+
}
|
|
42909
|
+
set ID(value) {
|
|
42910
|
+
this.Set('ID', value);
|
|
42911
|
+
}
|
|
42912
|
+
/**
|
|
42913
|
+
* * Field Name: EntityMapID
|
|
42914
|
+
* * Display Name: Entity Map
|
|
42915
|
+
* * SQL Data Type: uniqueidentifier
|
|
42916
|
+
* * Related Entity/Foreign Key: MJ: Company Integration Entity Maps (vwCompanyIntegrationEntityMaps.ID)
|
|
42917
|
+
*/
|
|
42918
|
+
get EntityMapID() {
|
|
42919
|
+
return this.Get('EntityMapID');
|
|
42920
|
+
}
|
|
42921
|
+
set EntityMapID(value) {
|
|
42922
|
+
this.Set('EntityMapID', value);
|
|
42923
|
+
}
|
|
42924
|
+
/**
|
|
42925
|
+
* * Field Name: Direction
|
|
42926
|
+
* * Display Name: Direction
|
|
42927
|
+
* * SQL Data Type: nvarchar(50)
|
|
42928
|
+
* * Default Value: Pull
|
|
42929
|
+
* * Value List Type: List
|
|
42930
|
+
* * Possible Values
|
|
42931
|
+
* * Pull
|
|
42932
|
+
* * Push
|
|
42933
|
+
* * Description: Sync direction this watermark tracks: Pull or Push.
|
|
42934
|
+
*/
|
|
42935
|
+
get Direction() {
|
|
42936
|
+
return this.Get('Direction');
|
|
42937
|
+
}
|
|
42938
|
+
set Direction(value) {
|
|
42939
|
+
this.Set('Direction', value);
|
|
42940
|
+
}
|
|
42941
|
+
/**
|
|
42942
|
+
* * Field Name: WatermarkType
|
|
42943
|
+
* * Display Name: Watermark Type
|
|
42944
|
+
* * SQL Data Type: nvarchar(50)
|
|
42945
|
+
* * Default Value: Timestamp
|
|
42946
|
+
* * Value List Type: List
|
|
42947
|
+
* * Possible Values
|
|
42948
|
+
* * ChangeToken
|
|
42949
|
+
* * Cursor
|
|
42950
|
+
* * Timestamp
|
|
42951
|
+
* * Version
|
|
42952
|
+
* * Description: The type of watermark: Timestamp, Cursor, ChangeToken, or Version.
|
|
42953
|
+
*/
|
|
42954
|
+
get WatermarkType() {
|
|
42955
|
+
return this.Get('WatermarkType');
|
|
42956
|
+
}
|
|
42957
|
+
set WatermarkType(value) {
|
|
42958
|
+
this.Set('WatermarkType', value);
|
|
42959
|
+
}
|
|
42960
|
+
/**
|
|
42961
|
+
* * Field Name: WatermarkValue
|
|
42962
|
+
* * Display Name: Watermark Value
|
|
42963
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
42964
|
+
* * Description: The serialized watermark value used to resume incremental sync.
|
|
42965
|
+
*/
|
|
42966
|
+
get WatermarkValue() {
|
|
42967
|
+
return this.Get('WatermarkValue');
|
|
42968
|
+
}
|
|
42969
|
+
set WatermarkValue(value) {
|
|
42970
|
+
this.Set('WatermarkValue', value);
|
|
42971
|
+
}
|
|
42972
|
+
/**
|
|
42973
|
+
* * Field Name: LastSyncAt
|
|
42974
|
+
* * Display Name: Last Sync At
|
|
42975
|
+
* * SQL Data Type: datetimeoffset
|
|
42976
|
+
* * Description: Timestamp of the last successful sync for this watermark.
|
|
42977
|
+
*/
|
|
42978
|
+
get LastSyncAt() {
|
|
42979
|
+
return this.Get('LastSyncAt');
|
|
42980
|
+
}
|
|
42981
|
+
set LastSyncAt(value) {
|
|
42982
|
+
this.Set('LastSyncAt', value);
|
|
42983
|
+
}
|
|
42984
|
+
/**
|
|
42985
|
+
* * Field Name: RecordsSynced
|
|
42986
|
+
* * Display Name: Records Synced
|
|
42987
|
+
* * SQL Data Type: int
|
|
42988
|
+
* * Default Value: 0
|
|
42989
|
+
* * Description: Cumulative count of records synced through this watermark.
|
|
42990
|
+
*/
|
|
42991
|
+
get RecordsSynced() {
|
|
42992
|
+
return this.Get('RecordsSynced');
|
|
42993
|
+
}
|
|
42994
|
+
set RecordsSynced(value) {
|
|
42995
|
+
this.Set('RecordsSynced', value);
|
|
42996
|
+
}
|
|
42997
|
+
/**
|
|
42998
|
+
* * Field Name: __mj_CreatedAt
|
|
42999
|
+
* * Display Name: Created At
|
|
43000
|
+
* * SQL Data Type: datetimeoffset
|
|
43001
|
+
* * Default Value: getutcdate()
|
|
43002
|
+
*/
|
|
43003
|
+
get __mj_CreatedAt() {
|
|
43004
|
+
return this.Get('__mj_CreatedAt');
|
|
43005
|
+
}
|
|
43006
|
+
/**
|
|
43007
|
+
* * Field Name: __mj_UpdatedAt
|
|
43008
|
+
* * Display Name: Updated At
|
|
43009
|
+
* * SQL Data Type: datetimeoffset
|
|
43010
|
+
* * Default Value: getutcdate()
|
|
43011
|
+
*/
|
|
43012
|
+
get __mj_UpdatedAt() {
|
|
43013
|
+
return this.Get('__mj_UpdatedAt');
|
|
43014
|
+
}
|
|
43015
|
+
/**
|
|
43016
|
+
* * Field Name: EntityMap
|
|
43017
|
+
* * Display Name: Entity Map Name
|
|
43018
|
+
* * SQL Data Type: nvarchar(500)
|
|
43019
|
+
*/
|
|
43020
|
+
get EntityMap() {
|
|
43021
|
+
return this.Get('EntityMap');
|
|
43022
|
+
}
|
|
43023
|
+
};
|
|
43024
|
+
MJCompanyIntegrationSyncWatermarkEntity = __decorate([
|
|
43025
|
+
RegisterClass(BaseEntity, 'MJ: Company Integration Sync Watermarks')
|
|
43026
|
+
], MJCompanyIntegrationSyncWatermarkEntity);
|
|
43027
|
+
export { MJCompanyIntegrationSyncWatermarkEntity };
|
|
41710
43028
|
/**
|
|
41711
43029
|
* MJ: Company Integrations - strongly typed entity sub-class
|
|
41712
43030
|
* * Schema: __mj
|
|
@@ -41773,7 +43091,7 @@ let MJCompanyIntegrationEntity = class MJCompanyIntegrationEntity extends BaseEn
|
|
|
41773
43091
|
}
|
|
41774
43092
|
/**
|
|
41775
43093
|
* * Field Name: IsActive
|
|
41776
|
-
* * Display Name: Active
|
|
43094
|
+
* * Display Name: Is Active
|
|
41777
43095
|
* * SQL Data Type: bit
|
|
41778
43096
|
* * Description: Controls whether this integration is currently active for the company.
|
|
41779
43097
|
*/
|
|
@@ -41923,6 +43241,172 @@ let MJCompanyIntegrationEntity = class MJCompanyIntegrationEntity extends BaseEn
|
|
|
41923
43241
|
this.Set('Name', value);
|
|
41924
43242
|
}
|
|
41925
43243
|
/**
|
|
43244
|
+
* * Field Name: SourceTypeID
|
|
43245
|
+
* * Display Name: Source Type
|
|
43246
|
+
* * SQL Data Type: uniqueidentifier
|
|
43247
|
+
* * Related Entity/Foreign Key: MJ: Integration Source Types (vwIntegrationSourceTypes.ID)
|
|
43248
|
+
* * Description: Links this integration to its source type (SaaS API, Database, File Feed, etc.).
|
|
43249
|
+
*/
|
|
43250
|
+
get SourceTypeID() {
|
|
43251
|
+
return this.Get('SourceTypeID');
|
|
43252
|
+
}
|
|
43253
|
+
set SourceTypeID(value) {
|
|
43254
|
+
this.Set('SourceTypeID', value);
|
|
43255
|
+
}
|
|
43256
|
+
/**
|
|
43257
|
+
* * Field Name: Configuration
|
|
43258
|
+
* * Display Name: Configuration
|
|
43259
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
43260
|
+
* * Description: JSON configuration for the integration connection (server, database, credentials reference, etc.).
|
|
43261
|
+
*/
|
|
43262
|
+
get Configuration() {
|
|
43263
|
+
return this.Get('Configuration');
|
|
43264
|
+
}
|
|
43265
|
+
set Configuration(value) {
|
|
43266
|
+
this.Set('Configuration', value);
|
|
43267
|
+
}
|
|
43268
|
+
/**
|
|
43269
|
+
* * Field Name: CredentialID
|
|
43270
|
+
* * Display Name: Credential
|
|
43271
|
+
* * SQL Data Type: uniqueidentifier
|
|
43272
|
+
* * Related Entity/Foreign Key: MJ: Credentials (vwCredentials.ID)
|
|
43273
|
+
* * Description: Optional reference to a Credential record that stores encrypted authentication values for this company integration. Replaces the legacy inline auth fields (AccessToken, RefreshToken, APIKey, etc.).
|
|
43274
|
+
*/
|
|
43275
|
+
get CredentialID() {
|
|
43276
|
+
return this.Get('CredentialID');
|
|
43277
|
+
}
|
|
43278
|
+
set CredentialID(value) {
|
|
43279
|
+
this.Set('CredentialID', value);
|
|
43280
|
+
}
|
|
43281
|
+
/**
|
|
43282
|
+
* * Field Name: ScheduleEnabled
|
|
43283
|
+
* * Display Name: Schedule Enabled
|
|
43284
|
+
* * SQL Data Type: bit
|
|
43285
|
+
* * Default Value: 0
|
|
43286
|
+
* * Description: Whether automatic sync scheduling is enabled for this integration
|
|
43287
|
+
*/
|
|
43288
|
+
get ScheduleEnabled() {
|
|
43289
|
+
return this.Get('ScheduleEnabled');
|
|
43290
|
+
}
|
|
43291
|
+
set ScheduleEnabled(value) {
|
|
43292
|
+
this.Set('ScheduleEnabled', value);
|
|
43293
|
+
}
|
|
43294
|
+
/**
|
|
43295
|
+
* * Field Name: ScheduleType
|
|
43296
|
+
* * Display Name: Schedule Type
|
|
43297
|
+
* * SQL Data Type: nvarchar(20)
|
|
43298
|
+
* * Default Value: Manual
|
|
43299
|
+
* * Value List Type: List
|
|
43300
|
+
* * Possible Values
|
|
43301
|
+
* * Cron
|
|
43302
|
+
* * Interval
|
|
43303
|
+
* * Manual
|
|
43304
|
+
* * Description: Type of schedule: Manual (no auto-sync), Interval (every N minutes), Cron (cron expression)
|
|
43305
|
+
*/
|
|
43306
|
+
get ScheduleType() {
|
|
43307
|
+
return this.Get('ScheduleType');
|
|
43308
|
+
}
|
|
43309
|
+
set ScheduleType(value) {
|
|
43310
|
+
this.Set('ScheduleType', value);
|
|
43311
|
+
}
|
|
43312
|
+
/**
|
|
43313
|
+
* * Field Name: ScheduleIntervalMinutes
|
|
43314
|
+
* * Display Name: Schedule Interval (Minutes)
|
|
43315
|
+
* * SQL Data Type: int
|
|
43316
|
+
* * Description: Interval in minutes for Interval schedule type
|
|
43317
|
+
*/
|
|
43318
|
+
get ScheduleIntervalMinutes() {
|
|
43319
|
+
return this.Get('ScheduleIntervalMinutes');
|
|
43320
|
+
}
|
|
43321
|
+
set ScheduleIntervalMinutes(value) {
|
|
43322
|
+
this.Set('ScheduleIntervalMinutes', value);
|
|
43323
|
+
}
|
|
43324
|
+
/**
|
|
43325
|
+
* * Field Name: CronExpression
|
|
43326
|
+
* * Display Name: Cron Expression
|
|
43327
|
+
* * SQL Data Type: nvarchar(200)
|
|
43328
|
+
* * Description: Cron expression for Cron schedule type (e.g., "0 *\/6 * * *" for every 6 hours)
|
|
43329
|
+
*/
|
|
43330
|
+
get CronExpression() {
|
|
43331
|
+
return this.Get('CronExpression');
|
|
43332
|
+
}
|
|
43333
|
+
set CronExpression(value) {
|
|
43334
|
+
this.Set('CronExpression', value);
|
|
43335
|
+
}
|
|
43336
|
+
/**
|
|
43337
|
+
* * Field Name: NextScheduledRunAt
|
|
43338
|
+
* * Display Name: Next Scheduled Run
|
|
43339
|
+
* * SQL Data Type: datetimeoffset
|
|
43340
|
+
* * Description: When the next scheduled sync should run. Updated after each run based on schedule config.
|
|
43341
|
+
*/
|
|
43342
|
+
get NextScheduledRunAt() {
|
|
43343
|
+
return this.Get('NextScheduledRunAt');
|
|
43344
|
+
}
|
|
43345
|
+
set NextScheduledRunAt(value) {
|
|
43346
|
+
this.Set('NextScheduledRunAt', value);
|
|
43347
|
+
}
|
|
43348
|
+
/**
|
|
43349
|
+
* * Field Name: LastScheduledRunAt
|
|
43350
|
+
* * Display Name: Last Scheduled Run
|
|
43351
|
+
* * SQL Data Type: datetimeoffset
|
|
43352
|
+
* * Description: When the last scheduled sync was initiated
|
|
43353
|
+
*/
|
|
43354
|
+
get LastScheduledRunAt() {
|
|
43355
|
+
return this.Get('LastScheduledRunAt');
|
|
43356
|
+
}
|
|
43357
|
+
set LastScheduledRunAt(value) {
|
|
43358
|
+
this.Set('LastScheduledRunAt', value);
|
|
43359
|
+
}
|
|
43360
|
+
/**
|
|
43361
|
+
* * Field Name: IsLocked
|
|
43362
|
+
* * Display Name: Is Locked
|
|
43363
|
+
* * SQL Data Type: bit
|
|
43364
|
+
* * Default Value: 0
|
|
43365
|
+
* * Description: Whether a sync is currently locked/running for this integration
|
|
43366
|
+
*/
|
|
43367
|
+
get IsLocked() {
|
|
43368
|
+
return this.Get('IsLocked');
|
|
43369
|
+
}
|
|
43370
|
+
set IsLocked(value) {
|
|
43371
|
+
this.Set('IsLocked', value);
|
|
43372
|
+
}
|
|
43373
|
+
/**
|
|
43374
|
+
* * Field Name: LockedAt
|
|
43375
|
+
* * Display Name: Locked At
|
|
43376
|
+
* * SQL Data Type: datetimeoffset
|
|
43377
|
+
* * Description: When the lock was acquired
|
|
43378
|
+
*/
|
|
43379
|
+
get LockedAt() {
|
|
43380
|
+
return this.Get('LockedAt');
|
|
43381
|
+
}
|
|
43382
|
+
set LockedAt(value) {
|
|
43383
|
+
this.Set('LockedAt', value);
|
|
43384
|
+
}
|
|
43385
|
+
/**
|
|
43386
|
+
* * Field Name: LockedByInstance
|
|
43387
|
+
* * Display Name: Locked By Instance
|
|
43388
|
+
* * SQL Data Type: nvarchar(200)
|
|
43389
|
+
* * Description: Server instance identifier that holds the lock (hostname-pid)
|
|
43390
|
+
*/
|
|
43391
|
+
get LockedByInstance() {
|
|
43392
|
+
return this.Get('LockedByInstance');
|
|
43393
|
+
}
|
|
43394
|
+
set LockedByInstance(value) {
|
|
43395
|
+
this.Set('LockedByInstance', value);
|
|
43396
|
+
}
|
|
43397
|
+
/**
|
|
43398
|
+
* * Field Name: LockExpiresAt
|
|
43399
|
+
* * Display Name: Lock Expires At
|
|
43400
|
+
* * SQL Data Type: datetimeoffset
|
|
43401
|
+
* * Description: When the lock should be considered stale and eligible for cleanup
|
|
43402
|
+
*/
|
|
43403
|
+
get LockExpiresAt() {
|
|
43404
|
+
return this.Get('LockExpiresAt');
|
|
43405
|
+
}
|
|
43406
|
+
set LockExpiresAt(value) {
|
|
43407
|
+
this.Set('LockExpiresAt', value);
|
|
43408
|
+
}
|
|
43409
|
+
/**
|
|
41926
43410
|
* * Field Name: Company
|
|
41927
43411
|
* * Display Name: Company
|
|
41928
43412
|
* * SQL Data Type: nvarchar(50)
|
|
@@ -56390,6 +57874,751 @@ MJGeneratedCodeEntity = __decorate([
|
|
|
56390
57874
|
RegisterClass(BaseEntity, 'MJ: Generated Codes')
|
|
56391
57875
|
], MJGeneratedCodeEntity);
|
|
56392
57876
|
export { MJGeneratedCodeEntity };
|
|
57877
|
+
/**
|
|
57878
|
+
* MJ: Integration Object Fields - strongly typed entity sub-class
|
|
57879
|
+
* * Schema: __mj
|
|
57880
|
+
* * Base Table: IntegrationObjectField
|
|
57881
|
+
* * Base View: vwIntegrationObjectFields
|
|
57882
|
+
* * @description Describes a field on an integration object, mirroring EntityField column patterns for type compatibility
|
|
57883
|
+
* * Primary Key: ID
|
|
57884
|
+
* @extends {BaseEntity}
|
|
57885
|
+
* @class
|
|
57886
|
+
* @public
|
|
57887
|
+
*/
|
|
57888
|
+
let MJIntegrationObjectFieldEntity = class MJIntegrationObjectFieldEntity extends BaseEntity {
|
|
57889
|
+
/**
|
|
57890
|
+
* Loads the MJ: Integration Object Fields record from the database
|
|
57891
|
+
* @param ID: string - primary key value to load the MJ: Integration Object Fields record.
|
|
57892
|
+
* @param EntityRelationshipsToLoad - (optional) the relationships to load
|
|
57893
|
+
* @returns {Promise<boolean>} - true if successful, false otherwise
|
|
57894
|
+
* @public
|
|
57895
|
+
* @async
|
|
57896
|
+
* @memberof MJIntegrationObjectFieldEntity
|
|
57897
|
+
* @method
|
|
57898
|
+
* @override
|
|
57899
|
+
*/
|
|
57900
|
+
async Load(ID, EntityRelationshipsToLoad) {
|
|
57901
|
+
const compositeKey = new CompositeKey();
|
|
57902
|
+
compositeKey.KeyValuePairs.push({ FieldName: 'ID', Value: ID });
|
|
57903
|
+
return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
|
|
57904
|
+
}
|
|
57905
|
+
/**
|
|
57906
|
+
* * Field Name: ID
|
|
57907
|
+
* * Display Name: ID
|
|
57908
|
+
* * SQL Data Type: uniqueidentifier
|
|
57909
|
+
* * Default Value: newsequentialid()
|
|
57910
|
+
* * Description: Primary key
|
|
57911
|
+
*/
|
|
57912
|
+
get ID() {
|
|
57913
|
+
return this.Get('ID');
|
|
57914
|
+
}
|
|
57915
|
+
set ID(value) {
|
|
57916
|
+
this.Set('ID', value);
|
|
57917
|
+
}
|
|
57918
|
+
/**
|
|
57919
|
+
* * Field Name: IntegrationObjectID
|
|
57920
|
+
* * Display Name: Integration Object
|
|
57921
|
+
* * SQL Data Type: uniqueidentifier
|
|
57922
|
+
* * Related Entity/Foreign Key: MJ: Integration Objects (vwIntegrationObjects.ID)
|
|
57923
|
+
* * Description: Foreign key to the IntegrationObject this field belongs to
|
|
57924
|
+
*/
|
|
57925
|
+
get IntegrationObjectID() {
|
|
57926
|
+
return this.Get('IntegrationObjectID');
|
|
57927
|
+
}
|
|
57928
|
+
set IntegrationObjectID(value) {
|
|
57929
|
+
this.Set('IntegrationObjectID', value);
|
|
57930
|
+
}
|
|
57931
|
+
/**
|
|
57932
|
+
* * Field Name: Name
|
|
57933
|
+
* * Display Name: Name
|
|
57934
|
+
* * SQL Data Type: nvarchar(255)
|
|
57935
|
+
* * Description: Field name as returned by the external API
|
|
57936
|
+
*/
|
|
57937
|
+
get Name() {
|
|
57938
|
+
return this.Get('Name');
|
|
57939
|
+
}
|
|
57940
|
+
set Name(value) {
|
|
57941
|
+
this.Set('Name', value);
|
|
57942
|
+
}
|
|
57943
|
+
/**
|
|
57944
|
+
* * Field Name: DisplayName
|
|
57945
|
+
* * Display Name: Display Name
|
|
57946
|
+
* * SQL Data Type: nvarchar(255)
|
|
57947
|
+
* * Description: Human-friendly display label for the field
|
|
57948
|
+
*/
|
|
57949
|
+
get DisplayName() {
|
|
57950
|
+
return this.Get('DisplayName');
|
|
57951
|
+
}
|
|
57952
|
+
set DisplayName(value) {
|
|
57953
|
+
this.Set('DisplayName', value);
|
|
57954
|
+
}
|
|
57955
|
+
/**
|
|
57956
|
+
* * Field Name: Description
|
|
57957
|
+
* * Display Name: Description
|
|
57958
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
57959
|
+
* * Description: Description of what this field represents
|
|
57960
|
+
*/
|
|
57961
|
+
get Description() {
|
|
57962
|
+
return this.Get('Description');
|
|
57963
|
+
}
|
|
57964
|
+
set Description(value) {
|
|
57965
|
+
this.Set('Description', value);
|
|
57966
|
+
}
|
|
57967
|
+
/**
|
|
57968
|
+
* * Field Name: Category
|
|
57969
|
+
* * Display Name: Category
|
|
57970
|
+
* * SQL Data Type: nvarchar(100)
|
|
57971
|
+
* * Description: UI grouping category within the object
|
|
57972
|
+
*/
|
|
57973
|
+
get Category() {
|
|
57974
|
+
return this.Get('Category');
|
|
57975
|
+
}
|
|
57976
|
+
set Category(value) {
|
|
57977
|
+
this.Set('Category', value);
|
|
57978
|
+
}
|
|
57979
|
+
/**
|
|
57980
|
+
* * Field Name: Type
|
|
57981
|
+
* * Display Name: Type
|
|
57982
|
+
* * SQL Data Type: nvarchar(100)
|
|
57983
|
+
* * Description: Data type of the field (e.g., nvarchar, int, datetime, decimal, bit). Uses same type vocabulary as EntityField.
|
|
57984
|
+
*/
|
|
57985
|
+
get Type() {
|
|
57986
|
+
return this.Get('Type');
|
|
57987
|
+
}
|
|
57988
|
+
set Type(value) {
|
|
57989
|
+
this.Set('Type', value);
|
|
57990
|
+
}
|
|
57991
|
+
/**
|
|
57992
|
+
* * Field Name: Length
|
|
57993
|
+
* * Display Name: Length
|
|
57994
|
+
* * SQL Data Type: int
|
|
57995
|
+
* * Description: Maximum length for string types
|
|
57996
|
+
*/
|
|
57997
|
+
get Length() {
|
|
57998
|
+
return this.Get('Length');
|
|
57999
|
+
}
|
|
58000
|
+
set Length(value) {
|
|
58001
|
+
this.Set('Length', value);
|
|
58002
|
+
}
|
|
58003
|
+
/**
|
|
58004
|
+
* * Field Name: Precision
|
|
58005
|
+
* * Display Name: Precision
|
|
58006
|
+
* * SQL Data Type: int
|
|
58007
|
+
* * Description: Numeric precision
|
|
58008
|
+
*/
|
|
58009
|
+
get Precision() {
|
|
58010
|
+
return this.Get('Precision');
|
|
58011
|
+
}
|
|
58012
|
+
set Precision(value) {
|
|
58013
|
+
this.Set('Precision', value);
|
|
58014
|
+
}
|
|
58015
|
+
/**
|
|
58016
|
+
* * Field Name: Scale
|
|
58017
|
+
* * Display Name: Scale
|
|
58018
|
+
* * SQL Data Type: int
|
|
58019
|
+
* * Description: Numeric scale
|
|
58020
|
+
*/
|
|
58021
|
+
get Scale() {
|
|
58022
|
+
return this.Get('Scale');
|
|
58023
|
+
}
|
|
58024
|
+
set Scale(value) {
|
|
58025
|
+
this.Set('Scale', value);
|
|
58026
|
+
}
|
|
58027
|
+
/**
|
|
58028
|
+
* * Field Name: AllowsNull
|
|
58029
|
+
* * Display Name: Allows Null
|
|
58030
|
+
* * SQL Data Type: bit
|
|
58031
|
+
* * Default Value: 1
|
|
58032
|
+
* * Description: Whether the field can contain NULL values
|
|
58033
|
+
*/
|
|
58034
|
+
get AllowsNull() {
|
|
58035
|
+
return this.Get('AllowsNull');
|
|
58036
|
+
}
|
|
58037
|
+
set AllowsNull(value) {
|
|
58038
|
+
this.Set('AllowsNull', value);
|
|
58039
|
+
}
|
|
58040
|
+
/**
|
|
58041
|
+
* * Field Name: DefaultValue
|
|
58042
|
+
* * Display Name: Default Value
|
|
58043
|
+
* * SQL Data Type: nvarchar(255)
|
|
58044
|
+
* * Description: Default value from the source system
|
|
58045
|
+
*/
|
|
58046
|
+
get DefaultValue() {
|
|
58047
|
+
return this.Get('DefaultValue');
|
|
58048
|
+
}
|
|
58049
|
+
set DefaultValue(value) {
|
|
58050
|
+
this.Set('DefaultValue', value);
|
|
58051
|
+
}
|
|
58052
|
+
/**
|
|
58053
|
+
* * Field Name: IsPrimaryKey
|
|
58054
|
+
* * Display Name: Primary Key
|
|
58055
|
+
* * SQL Data Type: bit
|
|
58056
|
+
* * Default Value: 0
|
|
58057
|
+
* * Description: Whether this field is part of the object primary key
|
|
58058
|
+
*/
|
|
58059
|
+
get IsPrimaryKey() {
|
|
58060
|
+
return this.Get('IsPrimaryKey');
|
|
58061
|
+
}
|
|
58062
|
+
set IsPrimaryKey(value) {
|
|
58063
|
+
this.Set('IsPrimaryKey', value);
|
|
58064
|
+
}
|
|
58065
|
+
/**
|
|
58066
|
+
* * Field Name: IsUniqueKey
|
|
58067
|
+
* * Display Name: Unique Key
|
|
58068
|
+
* * SQL Data Type: bit
|
|
58069
|
+
* * Default Value: 0
|
|
58070
|
+
* * Description: Whether values must be unique across all records
|
|
58071
|
+
*/
|
|
58072
|
+
get IsUniqueKey() {
|
|
58073
|
+
return this.Get('IsUniqueKey');
|
|
58074
|
+
}
|
|
58075
|
+
set IsUniqueKey(value) {
|
|
58076
|
+
this.Set('IsUniqueKey', value);
|
|
58077
|
+
}
|
|
58078
|
+
/**
|
|
58079
|
+
* * Field Name: IsReadOnly
|
|
58080
|
+
* * Display Name: Read Only
|
|
58081
|
+
* * SQL Data Type: bit
|
|
58082
|
+
* * Default Value: 0
|
|
58083
|
+
* * Description: Whether this field cannot be written back to the source system
|
|
58084
|
+
*/
|
|
58085
|
+
get IsReadOnly() {
|
|
58086
|
+
return this.Get('IsReadOnly');
|
|
58087
|
+
}
|
|
58088
|
+
set IsReadOnly(value) {
|
|
58089
|
+
this.Set('IsReadOnly', value);
|
|
58090
|
+
}
|
|
58091
|
+
/**
|
|
58092
|
+
* * Field Name: IsRequired
|
|
58093
|
+
* * Display Name: Required
|
|
58094
|
+
* * SQL Data Type: bit
|
|
58095
|
+
* * Default Value: 0
|
|
58096
|
+
* * Description: Whether this field is required for create/update operations
|
|
58097
|
+
*/
|
|
58098
|
+
get IsRequired() {
|
|
58099
|
+
return this.Get('IsRequired');
|
|
58100
|
+
}
|
|
58101
|
+
set IsRequired(value) {
|
|
58102
|
+
this.Set('IsRequired', value);
|
|
58103
|
+
}
|
|
58104
|
+
/**
|
|
58105
|
+
* * Field Name: RelatedIntegrationObjectID
|
|
58106
|
+
* * Display Name: Related Integration Object
|
|
58107
|
+
* * SQL Data Type: uniqueidentifier
|
|
58108
|
+
* * Related Entity/Foreign Key: MJ: Integration Objects (vwIntegrationObjects.ID)
|
|
58109
|
+
* * Description: Foreign key to another IntegrationObject, establishing a relationship. Used for DAG-based dependency ordering and template variable resolution in parent APIPath patterns.
|
|
58110
|
+
*/
|
|
58111
|
+
get RelatedIntegrationObjectID() {
|
|
58112
|
+
return this.Get('RelatedIntegrationObjectID');
|
|
58113
|
+
}
|
|
58114
|
+
set RelatedIntegrationObjectID(value) {
|
|
58115
|
+
this.Set('RelatedIntegrationObjectID', value);
|
|
58116
|
+
}
|
|
58117
|
+
/**
|
|
58118
|
+
* * Field Name: RelatedIntegrationObjectFieldName
|
|
58119
|
+
* * Display Name: Related Field Name
|
|
58120
|
+
* * SQL Data Type: nvarchar(255)
|
|
58121
|
+
* * Description: The field name on the related IntegrationObject that this FK points to (typically the PK field)
|
|
58122
|
+
*/
|
|
58123
|
+
get RelatedIntegrationObjectFieldName() {
|
|
58124
|
+
return this.Get('RelatedIntegrationObjectFieldName');
|
|
58125
|
+
}
|
|
58126
|
+
set RelatedIntegrationObjectFieldName(value) {
|
|
58127
|
+
this.Set('RelatedIntegrationObjectFieldName', value);
|
|
58128
|
+
}
|
|
58129
|
+
/**
|
|
58130
|
+
* * Field Name: Sequence
|
|
58131
|
+
* * Display Name: Sequence
|
|
58132
|
+
* * SQL Data Type: int
|
|
58133
|
+
* * Default Value: 0
|
|
58134
|
+
* * Description: Display and processing order within the object. Lower numbers appear first.
|
|
58135
|
+
*/
|
|
58136
|
+
get Sequence() {
|
|
58137
|
+
return this.Get('Sequence');
|
|
58138
|
+
}
|
|
58139
|
+
set Sequence(value) {
|
|
58140
|
+
this.Set('Sequence', value);
|
|
58141
|
+
}
|
|
58142
|
+
/**
|
|
58143
|
+
* * Field Name: Configuration
|
|
58144
|
+
* * Display Name: Configuration
|
|
58145
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
58146
|
+
* * Description: Freeform JSON for connector-specific field configuration
|
|
58147
|
+
*/
|
|
58148
|
+
get Configuration() {
|
|
58149
|
+
return this.Get('Configuration');
|
|
58150
|
+
}
|
|
58151
|
+
set Configuration(value) {
|
|
58152
|
+
this.Set('Configuration', value);
|
|
58153
|
+
}
|
|
58154
|
+
/**
|
|
58155
|
+
* * Field Name: Status
|
|
58156
|
+
* * Display Name: Status
|
|
58157
|
+
* * SQL Data Type: nvarchar(25)
|
|
58158
|
+
* * Default Value: Active
|
|
58159
|
+
* * Value List Type: List
|
|
58160
|
+
* * Possible Values
|
|
58161
|
+
* * Active
|
|
58162
|
+
* * Deprecated
|
|
58163
|
+
* * Disabled
|
|
58164
|
+
* * Description: Active, Deprecated, or Disabled. Mirrors EntityField status values.
|
|
58165
|
+
*/
|
|
58166
|
+
get Status() {
|
|
58167
|
+
return this.Get('Status');
|
|
58168
|
+
}
|
|
58169
|
+
set Status(value) {
|
|
58170
|
+
this.Set('Status', value);
|
|
58171
|
+
}
|
|
58172
|
+
/**
|
|
58173
|
+
* * Field Name: __mj_CreatedAt
|
|
58174
|
+
* * Display Name: Created At
|
|
58175
|
+
* * SQL Data Type: datetimeoffset
|
|
58176
|
+
* * Default Value: getutcdate()
|
|
58177
|
+
*/
|
|
58178
|
+
get __mj_CreatedAt() {
|
|
58179
|
+
return this.Get('__mj_CreatedAt');
|
|
58180
|
+
}
|
|
58181
|
+
/**
|
|
58182
|
+
* * Field Name: __mj_UpdatedAt
|
|
58183
|
+
* * Display Name: Updated At
|
|
58184
|
+
* * SQL Data Type: datetimeoffset
|
|
58185
|
+
* * Default Value: getutcdate()
|
|
58186
|
+
*/
|
|
58187
|
+
get __mj_UpdatedAt() {
|
|
58188
|
+
return this.Get('__mj_UpdatedAt');
|
|
58189
|
+
}
|
|
58190
|
+
/**
|
|
58191
|
+
* * Field Name: IntegrationObject
|
|
58192
|
+
* * Display Name: Integration Object Name
|
|
58193
|
+
* * SQL Data Type: nvarchar(255)
|
|
58194
|
+
*/
|
|
58195
|
+
get IntegrationObject() {
|
|
58196
|
+
return this.Get('IntegrationObject');
|
|
58197
|
+
}
|
|
58198
|
+
/**
|
|
58199
|
+
* * Field Name: RelatedIntegrationObject
|
|
58200
|
+
* * Display Name: Related Object Name
|
|
58201
|
+
* * SQL Data Type: nvarchar(255)
|
|
58202
|
+
*/
|
|
58203
|
+
get RelatedIntegrationObject() {
|
|
58204
|
+
return this.Get('RelatedIntegrationObject');
|
|
58205
|
+
}
|
|
58206
|
+
};
|
|
58207
|
+
MJIntegrationObjectFieldEntity = __decorate([
|
|
58208
|
+
RegisterClass(BaseEntity, 'MJ: Integration Object Fields')
|
|
58209
|
+
], MJIntegrationObjectFieldEntity);
|
|
58210
|
+
export { MJIntegrationObjectFieldEntity };
|
|
58211
|
+
/**
|
|
58212
|
+
* MJ: Integration Objects - strongly typed entity sub-class
|
|
58213
|
+
* * Schema: __mj
|
|
58214
|
+
* * Base Table: IntegrationObject
|
|
58215
|
+
* * Base View: vwIntegrationObjects
|
|
58216
|
+
* * @description Describes an external object or endpoint exposed by an integration (e.g., Members, Events, Invoices)
|
|
58217
|
+
* * Primary Key: ID
|
|
58218
|
+
* @extends {BaseEntity}
|
|
58219
|
+
* @class
|
|
58220
|
+
* @public
|
|
58221
|
+
*/
|
|
58222
|
+
let MJIntegrationObjectEntity = class MJIntegrationObjectEntity extends BaseEntity {
|
|
58223
|
+
/**
|
|
58224
|
+
* Loads the MJ: Integration Objects record from the database
|
|
58225
|
+
* @param ID: string - primary key value to load the MJ: Integration Objects record.
|
|
58226
|
+
* @param EntityRelationshipsToLoad - (optional) the relationships to load
|
|
58227
|
+
* @returns {Promise<boolean>} - true if successful, false otherwise
|
|
58228
|
+
* @public
|
|
58229
|
+
* @async
|
|
58230
|
+
* @memberof MJIntegrationObjectEntity
|
|
58231
|
+
* @method
|
|
58232
|
+
* @override
|
|
58233
|
+
*/
|
|
58234
|
+
async Load(ID, EntityRelationshipsToLoad) {
|
|
58235
|
+
const compositeKey = new CompositeKey();
|
|
58236
|
+
compositeKey.KeyValuePairs.push({ FieldName: 'ID', Value: ID });
|
|
58237
|
+
return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
|
|
58238
|
+
}
|
|
58239
|
+
/**
|
|
58240
|
+
* * Field Name: ID
|
|
58241
|
+
* * Display Name: ID
|
|
58242
|
+
* * SQL Data Type: uniqueidentifier
|
|
58243
|
+
* * Default Value: newsequentialid()
|
|
58244
|
+
* * Description: Primary key
|
|
58245
|
+
*/
|
|
58246
|
+
get ID() {
|
|
58247
|
+
return this.Get('ID');
|
|
58248
|
+
}
|
|
58249
|
+
set ID(value) {
|
|
58250
|
+
this.Set('ID', value);
|
|
58251
|
+
}
|
|
58252
|
+
/**
|
|
58253
|
+
* * Field Name: IntegrationID
|
|
58254
|
+
* * Display Name: Integration
|
|
58255
|
+
* * SQL Data Type: uniqueidentifier
|
|
58256
|
+
* * Related Entity/Foreign Key: MJ: Integrations (vwIntegrations.ID)
|
|
58257
|
+
* * Description: Foreign key to the Integration that owns this object
|
|
58258
|
+
*/
|
|
58259
|
+
get IntegrationID() {
|
|
58260
|
+
return this.Get('IntegrationID');
|
|
58261
|
+
}
|
|
58262
|
+
set IntegrationID(value) {
|
|
58263
|
+
this.Set('IntegrationID', value);
|
|
58264
|
+
}
|
|
58265
|
+
/**
|
|
58266
|
+
* * Field Name: Name
|
|
58267
|
+
* * Display Name: Internal Name
|
|
58268
|
+
* * SQL Data Type: nvarchar(255)
|
|
58269
|
+
* * Description: Internal/programmatic name of the external object (e.g., Members, Events)
|
|
58270
|
+
*/
|
|
58271
|
+
get Name() {
|
|
58272
|
+
return this.Get('Name');
|
|
58273
|
+
}
|
|
58274
|
+
set Name(value) {
|
|
58275
|
+
this.Set('Name', value);
|
|
58276
|
+
}
|
|
58277
|
+
/**
|
|
58278
|
+
* * Field Name: DisplayName
|
|
58279
|
+
* * Display Name: Display Name
|
|
58280
|
+
* * SQL Data Type: nvarchar(255)
|
|
58281
|
+
* * Description: Human-friendly display label
|
|
58282
|
+
*/
|
|
58283
|
+
get DisplayName() {
|
|
58284
|
+
return this.Get('DisplayName');
|
|
58285
|
+
}
|
|
58286
|
+
set DisplayName(value) {
|
|
58287
|
+
this.Set('DisplayName', value);
|
|
58288
|
+
}
|
|
58289
|
+
/**
|
|
58290
|
+
* * Field Name: Description
|
|
58291
|
+
* * Display Name: Description
|
|
58292
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
58293
|
+
* * Description: Description of what this external object represents
|
|
58294
|
+
*/
|
|
58295
|
+
get Description() {
|
|
58296
|
+
return this.Get('Description');
|
|
58297
|
+
}
|
|
58298
|
+
set Description(value) {
|
|
58299
|
+
this.Set('Description', value);
|
|
58300
|
+
}
|
|
58301
|
+
/**
|
|
58302
|
+
* * Field Name: Category
|
|
58303
|
+
* * Display Name: Category
|
|
58304
|
+
* * SQL Data Type: nvarchar(100)
|
|
58305
|
+
* * Description: UI grouping category (e.g., Membership, Events, Finance)
|
|
58306
|
+
*/
|
|
58307
|
+
get Category() {
|
|
58308
|
+
return this.Get('Category');
|
|
58309
|
+
}
|
|
58310
|
+
set Category(value) {
|
|
58311
|
+
this.Set('Category', value);
|
|
58312
|
+
}
|
|
58313
|
+
/**
|
|
58314
|
+
* * Field Name: APIPath
|
|
58315
|
+
* * Display Name: API Path
|
|
58316
|
+
* * SQL Data Type: nvarchar(500)
|
|
58317
|
+
* * Description: API endpoint path, may include template variables like {ProfileID} that are resolved at runtime from parent object records
|
|
58318
|
+
*/
|
|
58319
|
+
get APIPath() {
|
|
58320
|
+
return this.Get('APIPath');
|
|
58321
|
+
}
|
|
58322
|
+
set APIPath(value) {
|
|
58323
|
+
this.Set('APIPath', value);
|
|
58324
|
+
}
|
|
58325
|
+
/**
|
|
58326
|
+
* * Field Name: ResponseDataKey
|
|
58327
|
+
* * Display Name: Response Data Key
|
|
58328
|
+
* * SQL Data Type: nvarchar(255)
|
|
58329
|
+
* * Description: JSON key used to extract the data array from the API response envelope. NULL means the response is a root-level array.
|
|
58330
|
+
*/
|
|
58331
|
+
get ResponseDataKey() {
|
|
58332
|
+
return this.Get('ResponseDataKey');
|
|
58333
|
+
}
|
|
58334
|
+
set ResponseDataKey(value) {
|
|
58335
|
+
this.Set('ResponseDataKey', value);
|
|
58336
|
+
}
|
|
58337
|
+
/**
|
|
58338
|
+
* * Field Name: DefaultPageSize
|
|
58339
|
+
* * Display Name: Default Page Size
|
|
58340
|
+
* * SQL Data Type: int
|
|
58341
|
+
* * Default Value: 100
|
|
58342
|
+
* * Description: Number of records to request per page from the API
|
|
58343
|
+
*/
|
|
58344
|
+
get DefaultPageSize() {
|
|
58345
|
+
return this.Get('DefaultPageSize');
|
|
58346
|
+
}
|
|
58347
|
+
set DefaultPageSize(value) {
|
|
58348
|
+
this.Set('DefaultPageSize', value);
|
|
58349
|
+
}
|
|
58350
|
+
/**
|
|
58351
|
+
* * Field Name: SupportsPagination
|
|
58352
|
+
* * Display Name: Supports Pagination
|
|
58353
|
+
* * SQL Data Type: bit
|
|
58354
|
+
* * Default Value: 1
|
|
58355
|
+
* * Description: Whether this endpoint supports paginated fetching
|
|
58356
|
+
*/
|
|
58357
|
+
get SupportsPagination() {
|
|
58358
|
+
return this.Get('SupportsPagination');
|
|
58359
|
+
}
|
|
58360
|
+
set SupportsPagination(value) {
|
|
58361
|
+
this.Set('SupportsPagination', value);
|
|
58362
|
+
}
|
|
58363
|
+
/**
|
|
58364
|
+
* * Field Name: PaginationType
|
|
58365
|
+
* * Display Name: Pagination Type
|
|
58366
|
+
* * SQL Data Type: nvarchar(20)
|
|
58367
|
+
* * Default Value: PageNumber
|
|
58368
|
+
* * Value List Type: List
|
|
58369
|
+
* * Possible Values
|
|
58370
|
+
* * Cursor
|
|
58371
|
+
* * None
|
|
58372
|
+
* * Offset
|
|
58373
|
+
* * PageNumber
|
|
58374
|
+
* * Description: Pagination strategy: PageNumber (page index), Offset (record offset), Cursor (opaque token), or None
|
|
58375
|
+
*/
|
|
58376
|
+
get PaginationType() {
|
|
58377
|
+
return this.Get('PaginationType');
|
|
58378
|
+
}
|
|
58379
|
+
set PaginationType(value) {
|
|
58380
|
+
this.Set('PaginationType', value);
|
|
58381
|
+
}
|
|
58382
|
+
/**
|
|
58383
|
+
* * Field Name: SupportsIncrementalSync
|
|
58384
|
+
* * Display Name: Supports Incremental Sync
|
|
58385
|
+
* * SQL Data Type: bit
|
|
58386
|
+
* * Default Value: 0
|
|
58387
|
+
* * Description: Whether this object supports watermark-based incremental sync
|
|
58388
|
+
*/
|
|
58389
|
+
get SupportsIncrementalSync() {
|
|
58390
|
+
return this.Get('SupportsIncrementalSync');
|
|
58391
|
+
}
|
|
58392
|
+
set SupportsIncrementalSync(value) {
|
|
58393
|
+
this.Set('SupportsIncrementalSync', value);
|
|
58394
|
+
}
|
|
58395
|
+
/**
|
|
58396
|
+
* * Field Name: SupportsWrite
|
|
58397
|
+
* * Display Name: Supports Write
|
|
58398
|
+
* * SQL Data Type: bit
|
|
58399
|
+
* * Default Value: 0
|
|
58400
|
+
* * Description: Whether data can be pushed back to this object via the API
|
|
58401
|
+
*/
|
|
58402
|
+
get SupportsWrite() {
|
|
58403
|
+
return this.Get('SupportsWrite');
|
|
58404
|
+
}
|
|
58405
|
+
set SupportsWrite(value) {
|
|
58406
|
+
this.Set('SupportsWrite', value);
|
|
58407
|
+
}
|
|
58408
|
+
/**
|
|
58409
|
+
* * Field Name: DefaultQueryParams
|
|
58410
|
+
* * Display Name: Default Query Parameters
|
|
58411
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
58412
|
+
* * Description: JSON object of default query parameters to include with every API request for this object
|
|
58413
|
+
*/
|
|
58414
|
+
get DefaultQueryParams() {
|
|
58415
|
+
return this.Get('DefaultQueryParams');
|
|
58416
|
+
}
|
|
58417
|
+
set DefaultQueryParams(value) {
|
|
58418
|
+
this.Set('DefaultQueryParams', value);
|
|
58419
|
+
}
|
|
58420
|
+
/**
|
|
58421
|
+
* * Field Name: Configuration
|
|
58422
|
+
* * Display Name: Configuration
|
|
58423
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
58424
|
+
* * Description: Freeform JSON for connector-specific configuration not covered by standard columns
|
|
58425
|
+
*/
|
|
58426
|
+
get Configuration() {
|
|
58427
|
+
return this.Get('Configuration');
|
|
58428
|
+
}
|
|
58429
|
+
set Configuration(value) {
|
|
58430
|
+
this.Set('Configuration', value);
|
|
58431
|
+
}
|
|
58432
|
+
/**
|
|
58433
|
+
* * Field Name: Sequence
|
|
58434
|
+
* * Display Name: Sequence
|
|
58435
|
+
* * SQL Data Type: int
|
|
58436
|
+
* * Default Value: 0
|
|
58437
|
+
* * Description: Processing and display order. Lower numbers are processed first.
|
|
58438
|
+
*/
|
|
58439
|
+
get Sequence() {
|
|
58440
|
+
return this.Get('Sequence');
|
|
58441
|
+
}
|
|
58442
|
+
set Sequence(value) {
|
|
58443
|
+
this.Set('Sequence', value);
|
|
58444
|
+
}
|
|
58445
|
+
/**
|
|
58446
|
+
* * Field Name: Status
|
|
58447
|
+
* * Display Name: Status
|
|
58448
|
+
* * SQL Data Type: nvarchar(25)
|
|
58449
|
+
* * Default Value: Active
|
|
58450
|
+
* * Value List Type: List
|
|
58451
|
+
* * Possible Values
|
|
58452
|
+
* * Active
|
|
58453
|
+
* * Deprecated
|
|
58454
|
+
* * Disabled
|
|
58455
|
+
* * Description: Active, Deprecated, or Disabled. Mirrors EntityField status values.
|
|
58456
|
+
*/
|
|
58457
|
+
get Status() {
|
|
58458
|
+
return this.Get('Status');
|
|
58459
|
+
}
|
|
58460
|
+
set Status(value) {
|
|
58461
|
+
this.Set('Status', value);
|
|
58462
|
+
}
|
|
58463
|
+
/**
|
|
58464
|
+
* * Field Name: __mj_CreatedAt
|
|
58465
|
+
* * Display Name: Created At
|
|
58466
|
+
* * SQL Data Type: datetimeoffset
|
|
58467
|
+
* * Default Value: getutcdate()
|
|
58468
|
+
*/
|
|
58469
|
+
get __mj_CreatedAt() {
|
|
58470
|
+
return this.Get('__mj_CreatedAt');
|
|
58471
|
+
}
|
|
58472
|
+
/**
|
|
58473
|
+
* * Field Name: __mj_UpdatedAt
|
|
58474
|
+
* * Display Name: Updated At
|
|
58475
|
+
* * SQL Data Type: datetimeoffset
|
|
58476
|
+
* * Default Value: getutcdate()
|
|
58477
|
+
*/
|
|
58478
|
+
get __mj_UpdatedAt() {
|
|
58479
|
+
return this.Get('__mj_UpdatedAt');
|
|
58480
|
+
}
|
|
58481
|
+
/**
|
|
58482
|
+
* * Field Name: Integration
|
|
58483
|
+
* * Display Name: Integration Name
|
|
58484
|
+
* * SQL Data Type: nvarchar(100)
|
|
58485
|
+
*/
|
|
58486
|
+
get Integration() {
|
|
58487
|
+
return this.Get('Integration');
|
|
58488
|
+
}
|
|
58489
|
+
};
|
|
58490
|
+
MJIntegrationObjectEntity = __decorate([
|
|
58491
|
+
RegisterClass(BaseEntity, 'MJ: Integration Objects')
|
|
58492
|
+
], MJIntegrationObjectEntity);
|
|
58493
|
+
export { MJIntegrationObjectEntity };
|
|
58494
|
+
/**
|
|
58495
|
+
* MJ: Integration Source Types - strongly typed entity sub-class
|
|
58496
|
+
* * Schema: __mj
|
|
58497
|
+
* * Base Table: IntegrationSourceType
|
|
58498
|
+
* * Base View: vwIntegrationSourceTypes
|
|
58499
|
+
* * @description Defines categories of integration sources such as SaaS API, Relational Database, or File Feed.
|
|
58500
|
+
* * Primary Key: ID
|
|
58501
|
+
* @extends {BaseEntity}
|
|
58502
|
+
* @class
|
|
58503
|
+
* @public
|
|
58504
|
+
*/
|
|
58505
|
+
let MJIntegrationSourceTypeEntity = class MJIntegrationSourceTypeEntity extends BaseEntity {
|
|
58506
|
+
/**
|
|
58507
|
+
* Loads the MJ: Integration Source Types record from the database
|
|
58508
|
+
* @param ID: string - primary key value to load the MJ: Integration Source Types record.
|
|
58509
|
+
* @param EntityRelationshipsToLoad - (optional) the relationships to load
|
|
58510
|
+
* @returns {Promise<boolean>} - true if successful, false otherwise
|
|
58511
|
+
* @public
|
|
58512
|
+
* @async
|
|
58513
|
+
* @memberof MJIntegrationSourceTypeEntity
|
|
58514
|
+
* @method
|
|
58515
|
+
* @override
|
|
58516
|
+
*/
|
|
58517
|
+
async Load(ID, EntityRelationshipsToLoad) {
|
|
58518
|
+
const compositeKey = new CompositeKey();
|
|
58519
|
+
compositeKey.KeyValuePairs.push({ FieldName: 'ID', Value: ID });
|
|
58520
|
+
return await super.InnerLoad(compositeKey, EntityRelationshipsToLoad);
|
|
58521
|
+
}
|
|
58522
|
+
/**
|
|
58523
|
+
* * Field Name: ID
|
|
58524
|
+
* * Display Name: ID
|
|
58525
|
+
* * SQL Data Type: uniqueidentifier
|
|
58526
|
+
* * Default Value: newsequentialid()
|
|
58527
|
+
*/
|
|
58528
|
+
get ID() {
|
|
58529
|
+
return this.Get('ID');
|
|
58530
|
+
}
|
|
58531
|
+
set ID(value) {
|
|
58532
|
+
this.Set('ID', value);
|
|
58533
|
+
}
|
|
58534
|
+
/**
|
|
58535
|
+
* * Field Name: Name
|
|
58536
|
+
* * Display Name: Name
|
|
58537
|
+
* * SQL Data Type: nvarchar(200)
|
|
58538
|
+
* * Description: Display name for this source type (e.g. SaaS API, Relational Database, File Feed).
|
|
58539
|
+
*/
|
|
58540
|
+
get Name() {
|
|
58541
|
+
return this.Get('Name');
|
|
58542
|
+
}
|
|
58543
|
+
set Name(value) {
|
|
58544
|
+
this.Set('Name', value);
|
|
58545
|
+
}
|
|
58546
|
+
/**
|
|
58547
|
+
* * Field Name: Description
|
|
58548
|
+
* * Display Name: Description
|
|
58549
|
+
* * SQL Data Type: nvarchar(MAX)
|
|
58550
|
+
* * Description: Optional longer description of this source type.
|
|
58551
|
+
*/
|
|
58552
|
+
get Description() {
|
|
58553
|
+
return this.Get('Description');
|
|
58554
|
+
}
|
|
58555
|
+
set Description(value) {
|
|
58556
|
+
this.Set('Description', value);
|
|
58557
|
+
}
|
|
58558
|
+
/**
|
|
58559
|
+
* * Field Name: DriverClass
|
|
58560
|
+
* * Display Name: Driver Class
|
|
58561
|
+
* * SQL Data Type: nvarchar(500)
|
|
58562
|
+
* * Description: Fully-qualified class name registered via @RegisterClass that implements BaseIntegrationConnector for this source type.
|
|
58563
|
+
*/
|
|
58564
|
+
get DriverClass() {
|
|
58565
|
+
return this.Get('DriverClass');
|
|
58566
|
+
}
|
|
58567
|
+
set DriverClass(value) {
|
|
58568
|
+
this.Set('DriverClass', value);
|
|
58569
|
+
}
|
|
58570
|
+
/**
|
|
58571
|
+
* * Field Name: IconClass
|
|
58572
|
+
* * Display Name: Icon Class
|
|
58573
|
+
* * SQL Data Type: nvarchar(200)
|
|
58574
|
+
* * Description: Font Awesome icon class for UI display.
|
|
58575
|
+
*/
|
|
58576
|
+
get IconClass() {
|
|
58577
|
+
return this.Get('IconClass');
|
|
58578
|
+
}
|
|
58579
|
+
set IconClass(value) {
|
|
58580
|
+
this.Set('IconClass', value);
|
|
58581
|
+
}
|
|
58582
|
+
/**
|
|
58583
|
+
* * Field Name: Status
|
|
58584
|
+
* * Display Name: Status
|
|
58585
|
+
* * SQL Data Type: nvarchar(50)
|
|
58586
|
+
* * Default Value: Active
|
|
58587
|
+
* * Value List Type: List
|
|
58588
|
+
* * Possible Values
|
|
58589
|
+
* * Active
|
|
58590
|
+
* * Inactive
|
|
58591
|
+
* * Description: Whether this source type is available for use. Active or Inactive.
|
|
58592
|
+
*/
|
|
58593
|
+
get Status() {
|
|
58594
|
+
return this.Get('Status');
|
|
58595
|
+
}
|
|
58596
|
+
set Status(value) {
|
|
58597
|
+
this.Set('Status', value);
|
|
58598
|
+
}
|
|
58599
|
+
/**
|
|
58600
|
+
* * Field Name: __mj_CreatedAt
|
|
58601
|
+
* * Display Name: Created At
|
|
58602
|
+
* * SQL Data Type: datetimeoffset
|
|
58603
|
+
* * Default Value: getutcdate()
|
|
58604
|
+
*/
|
|
58605
|
+
get __mj_CreatedAt() {
|
|
58606
|
+
return this.Get('__mj_CreatedAt');
|
|
58607
|
+
}
|
|
58608
|
+
/**
|
|
58609
|
+
* * Field Name: __mj_UpdatedAt
|
|
58610
|
+
* * Display Name: Updated At
|
|
58611
|
+
* * SQL Data Type: datetimeoffset
|
|
58612
|
+
* * Default Value: getutcdate()
|
|
58613
|
+
*/
|
|
58614
|
+
get __mj_UpdatedAt() {
|
|
58615
|
+
return this.Get('__mj_UpdatedAt');
|
|
58616
|
+
}
|
|
58617
|
+
};
|
|
58618
|
+
MJIntegrationSourceTypeEntity = __decorate([
|
|
58619
|
+
RegisterClass(BaseEntity, 'MJ: Integration Source Types')
|
|
58620
|
+
], MJIntegrationSourceTypeEntity);
|
|
58621
|
+
export { MJIntegrationSourceTypeEntity };
|
|
56393
58622
|
/**
|
|
56394
58623
|
* MJ: Integration URL Formats - strongly typed entity sub-class
|
|
56395
58624
|
* * Schema: __mj
|
|
@@ -56553,6 +58782,7 @@ let MJIntegrationEntity = class MJIntegrationEntity extends BaseEntity {
|
|
|
56553
58782
|
}
|
|
56554
58783
|
/**
|
|
56555
58784
|
* * Field Name: Name
|
|
58785
|
+
* * Display Name: Name
|
|
56556
58786
|
* * SQL Data Type: nvarchar(100)
|
|
56557
58787
|
*/
|
|
56558
58788
|
get Name() {
|
|
@@ -56563,6 +58793,7 @@ let MJIntegrationEntity = class MJIntegrationEntity extends BaseEntity {
|
|
|
56563
58793
|
}
|
|
56564
58794
|
/**
|
|
56565
58795
|
* * Field Name: Description
|
|
58796
|
+
* * Display Name: Description
|
|
56566
58797
|
* * SQL Data Type: nvarchar(255)
|
|
56567
58798
|
*/
|
|
56568
58799
|
get Description() {
|
|
@@ -56653,6 +58884,7 @@ let MJIntegrationEntity = class MJIntegrationEntity extends BaseEntity {
|
|
|
56653
58884
|
}
|
|
56654
58885
|
/**
|
|
56655
58886
|
* * Field Name: ID
|
|
58887
|
+
* * Display Name: ID
|
|
56656
58888
|
* * SQL Data Type: uniqueidentifier
|
|
56657
58889
|
* * Default Value: newsequentialid()
|
|
56658
58890
|
*/
|
|
@@ -56662,6 +58894,27 @@ let MJIntegrationEntity = class MJIntegrationEntity extends BaseEntity {
|
|
|
56662
58894
|
set ID(value) {
|
|
56663
58895
|
this.Set('ID', value);
|
|
56664
58896
|
}
|
|
58897
|
+
/**
|
|
58898
|
+
* * Field Name: CredentialTypeID
|
|
58899
|
+
* * Display Name: Credential Type
|
|
58900
|
+
* * SQL Data Type: uniqueidentifier
|
|
58901
|
+
* * Related Entity/Foreign Key: MJ: Credential Types (vwCredentialTypes.ID)
|
|
58902
|
+
* * Description: Optional link to the credential type required by this integration. Used by the UI to pre-select the credential type when creating new credentials and to filter existing credentials.
|
|
58903
|
+
*/
|
|
58904
|
+
get CredentialTypeID() {
|
|
58905
|
+
return this.Get('CredentialTypeID');
|
|
58906
|
+
}
|
|
58907
|
+
set CredentialTypeID(value) {
|
|
58908
|
+
this.Set('CredentialTypeID', value);
|
|
58909
|
+
}
|
|
58910
|
+
/**
|
|
58911
|
+
* * Field Name: CredentialType
|
|
58912
|
+
* * Display Name: Credential Type Name
|
|
58913
|
+
* * SQL Data Type: nvarchar(100)
|
|
58914
|
+
*/
|
|
58915
|
+
get CredentialType() {
|
|
58916
|
+
return this.Get('CredentialType');
|
|
58917
|
+
}
|
|
56665
58918
|
};
|
|
56666
58919
|
MJIntegrationEntity = __decorate([
|
|
56667
58920
|
RegisterClass(BaseEntity, 'MJ: Integrations')
|