@segment/action-destinations 3.312.0 → 3.312.1-staging-1989539c2

package/dist/destinations/hubspot/upsertObject/hubspot-api.d.ts

@@ -0,0 +1,219 @@
+import { RequestClient, ModifiedResponse } from '@segment/actions-core';
+import { Payload } from './generated-types';
+export declare const SyncMode: {
+    readonly Upsert: "upsert";
+    readonly Add: "add";
+    readonly Update: "update";
+};
+export declare type SyncMode = typeof SyncMode[keyof typeof SyncMode];
+export declare const AssociationSyncMode: {
+    readonly Upsert: "upsert";
+    readonly Read: "read";
+};
+export declare type AssociationSyncMode = typeof AssociationSyncMode[keyof typeof AssociationSyncMode];
+declare const BatchRequestType: {
+    readonly Upsert: "upsert";
+    readonly Create: "create";
+    readonly Update: "update";
+    readonly Read: "read";
+};
+declare type BatchRequestType = typeof BatchRequestType[keyof typeof BatchRequestType];
+declare const HSPropTypeFieldType: {
+    readonly StringText: "string:text";
+    readonly NumberNumber: "number:number";
+    readonly DateTimeDate: "datetime:date";
+    readonly DateDate: "date:date";
+    readonly EnumerationBooleanCheckbox: "enumeration:booleancheckbox";
+};
+declare type HSPropTypeFieldType = typeof HSPropTypeFieldType[keyof typeof HSPropTypeFieldType];
+declare const HSPropType: {
+    readonly Date: "date";
+    readonly String: "string";
+    readonly DateTime: "datetime";
+    readonly Number: "number";
+    readonly Enumeration: "enumeration";
+};
+declare type HSPropType = typeof HSPropType[keyof typeof HSPropType];
+declare const HSPropFieldType: {
+    readonly Text: "text";
+    readonly Number: "number";
+    readonly Date: "date";
+    readonly BooleanCheckbox: "booleancheckbox";
+};
+declare type HSPropFieldType = typeof HSPropFieldType[keyof typeof HSPropFieldType];
+export declare const SchemaMatch: {
+    readonly FullMatch: "full_match";
+    readonly PropertiesMissing: "properties_missing";
+    readonly NoMatch: "no_match";
+    readonly Mismatch: "mismatch";
+};
+export declare type SchemaMatch = typeof SchemaMatch[keyof typeof SchemaMatch];
+declare const ReadType: {
+    readonly ReturnRecordsWithIds: "return_records_with_ids";
+    readonly ReturnRecordsWithoutIds: "return_records_without_ids";
+};
+declare type ReadType = typeof ReadType[keyof typeof ReadType];
+interface Prop {
+    name: string;
+    type: HSPropType;
+    fieldType: HSPropFieldType;
+    typeFieldType: HSPropTypeFieldType;
+}
+interface Schema {
+    object_details: {
+        object_type: string;
+        id_field_name: string;
+    };
+    properties: Prop[];
+    sensitiveProperties: Prop[];
+}
+interface SchemaDiff {
+    match: SchemaMatch;
+    object_details: {
+        object_type: string;
+        id_field_name: string;
+    };
+    missingProperties: Prop[];
+    missingSensitiveProperties: Prop[];
+}
+interface ResponseType {
+    status: 'fulfilled' | 'rejected';
+    value?: {
+        data: {
+            results: Result[];
+        };
+    };
+    reason?: {
+        message: string;
+    };
+}
+interface Result {
+    name: string;
+    type: HSPropType;
+    fieldType: HSPropFieldType;
+    hasUniqueValue: boolean;
+}
+interface ReadJSON {
+    idProperty: string;
+    properties: string[];
+    inputs: Array<{
+        id: string;
+    }>;
+}
+interface UpsertJSON {
+    inputs: Array<{
+        idProperty: string;
+        id: string;
+        properties: Record<string, string>;
+    }>;
+}
+interface CreateJSON {
+    inputs: Array<{
+        idProperty: string;
+        properties: Record<string, string>;
+    }>;
+}
+interface RespJSON {
+    status: string;
+    results: Array<{
+        id: string;
+        properties: Record<string, string | null>;
+    }>;
+}
+interface OmitPayload extends Omit<Payload, 'enable_batching' | 'batch_size' | 'association_sync_mode'> {
+}
+interface PayloadWithFromId extends OmitPayload {
+    object_details: OmitPayload['object_details'] & {
+        record_id: string;
+    };
+    associations?: Array<{
+        object_type: string;
+        association_label: string;
+        id_field_name: string;
+        id_field_value: string;
+        from_record_id: string;
+    }>;
+}
+interface AssociationPayload extends OmitPayload {
+    object_details: OmitPayload['object_details'] & {
+        from_record_id: string;
+    };
+    association_details: {
+        association_label: string;
+    };
+}
+interface AssociationPayloadWithId extends AssociationPayload {
+    object_details: AssociationPayload['object_details'] & {
+        record_id: string;
+    };
+}
+interface AssociationType {
+    associationCategory: AssociationCategory;
+    associationTypeId: string;
+}
+declare enum AssociationCategory {
+    HUBSPOT_DEFINED = "HUBSPOT_DEFINED",
+    USER_DEFINED = "USER_DEFINED",
+    INTEGRATOR_DEFINED = "INTEGRATOR_DEFINED"
+}
+interface BatchAssociationsRequestBody {
+    inputs: {
+        types: AssociationType[];
+        from: {
+            id: string;
+        };
+        to: {
+            id: string;
+        };
+    }[];
+}
+interface GroupableFields {
+    object_type: string;
+    id_field_name: string;
+}
+export declare class HubspotClient {
+    request: RequestClient;
+    objectType: string;
+    syncMode: SyncMode;
+    associationSyncMode: AssociationSyncMode;
+    propertyGroup?: string;
+    constructor(request: RequestClient, objectType: string, syncMode: SyncMode, associationSyncMode: AssociationSyncMode, propertyGroup: string | undefined);
+    cleanProp(str: string): string;
+    cleanPropObj(obj: {
+        [k: string]: unknown;
+    } | undefined): {
+        [k: string]: string | number | boolean;
+    } | undefined;
+    validate(payloads: Payload[]): Payload[];
+    format(value: unknown): {
+        type: HSPropType;
+        fieldType: HSPropFieldType;
+    };
+    formatHS(type: HSPropType, fieldType: HSPropFieldType): HSPropTypeFieldType;
+    schema(payloads: Payload[]): Schema;
+    schemaDiffCache(schema: Schema): Promise<SchemaDiff>;
+    saveSchemaToCache(schema: Schema): Promise<void>;
+    determineMissingPropsAndMatchType(response: ResponseType, properties: Prop[]): {
+        missingProps: Prop[];
+        match: SchemaMatch;
+    };
+    schemaDiffHubspot(schema: Schema): Promise<SchemaDiff>;
+    createProperties(schemaDiff: SchemaDiff): Promise<void>;
+    batchObjectRequest(action: BatchRequestType, objectType: string, data: ReadJSON | UpsertJSON | CreateJSON): Promise<ModifiedResponse<RespJSON>>;
+    sendFromRecords(payloads: Payload[]): Promise<PayloadWithFromId[]>;
+    readRecords(payloads: Payload[], objectType: string, readType: ReadType): Promise<PayloadWithFromId[] | Payload[]>;
+    upsertRecords(payloads: Payload[], objectType: string): Promise<PayloadWithFromId[]>;
+    updateRecords(payloads: Payload[], objectType: string): Promise<PayloadWithFromId[]>;
+    addRecords(payloads: Payload[], objectType: string): Promise<PayloadWithFromId[]>;
+    returnRecordsWithIds(payloads: Payload[], response: ModifiedResponse<RespJSON>): PayloadWithFromId[];
+    returnRecordsWithoutIds(payloads: Payload[], response: ModifiedResponse<RespJSON>): Payload[];
+    createAssociationPayloads(payloads: PayloadWithFromId[]): AssociationPayload[][];
+    groupPayloads(associations: AssociationPayload[], groupBy: (keyof GroupableFields)[]): AssociationPayload[][];
+    sendAssociatedRecords(payloads: AssociationPayload[][]): Promise<AssociationPayloadWithId[]>;
+    readAssociatedRecords(groupedPayloads: AssociationPayload[][]): Promise<AssociationPayloadWithId[]>;
+    upsertAssociatedRecords(groupedPayloads: AssociationPayload[][]): Promise<AssociationPayloadWithId[]>;
+    returnAssociatedRecordsWithIds(groupedPayloads: AssociationPayload[][], responses: ModifiedResponse<RespJSON>[]): AssociationPayloadWithId[];
+    batchAssociationsRequest(body: BatchAssociationsRequestBody, toObjectType: string): Promise<ModifiedResponse<unknown>>;
+    sendAssociations(payloads: AssociationPayloadWithId[]): Promise<void>;
+}
+export {};