@pear-protocol/types 0.1.0 → 1.1.0

package/dist/auth/api-keys.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+export declare const ApiKeyScope: z.ZodEnum<{
+    read: "read";
+    read_write: "read_write";
+}>;
+export declare const CreateApiKeyInput: z.ZodObject<{
+    label: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        read: "read";
+        read_write: "read_write";
+    }>>;
+    expiresAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>;
+export declare const CreateApiKeyOutput: z.ZodObject<{
+    id: z.ZodUUID;
+    label: z.ZodString;
+    scope: z.ZodEnum<{
+        read: "read";
+        read_write: "read_write";
+    }>;
+    key: z.ZodString;
+}, z.core.$strip>;
+export declare const ApiKeySummary: z.ZodObject<{
+    id: z.ZodUUID;
+    label: z.ZodString;
+    scope: z.ZodEnum<{
+        read: "read";
+        read_write: "read_write";
+    }>;
+    keyPrefix: z.ZodString;
+    lastUsedAt: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    revokedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare const ListApiKeysOutput: z.ZodArray<z.ZodObject<{
+    id: z.ZodUUID;
+    label: z.ZodString;
+    scope: z.ZodEnum<{
+        read: "read";
+        read_write: "read_write";
+    }>;
+    keyPrefix: z.ZodString;
+    lastUsedAt: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    revokedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>>;
+export declare const ApiKeyMeResponse: z.ZodObject<{
+    id: z.ZodUUID;
+    role: z.ZodEnum<{
+        basic: "basic";
+        pro: "pro";
+        admin: "admin";
+    }>;
+    scope: z.ZodEnum<{
+        read: "read";
+        read_write: "read_write";
+    }>;
+    authMethod: z.ZodLiteral<"api_key">;
+}, z.core.$strip>;
+export type ApiKeyScope = z.infer<typeof ApiKeyScope>;
+export type CreateApiKeyInput = z.infer<typeof CreateApiKeyInput>;
+export type CreateApiKeyOutput = z.infer<typeof CreateApiKeyOutput>;
+export type ApiKeySummary = z.infer<typeof ApiKeySummary>;
+export type ListApiKeysOutput = z.infer<typeof ListApiKeysOutput>;
+export type ApiKeyMeResponse = z.infer<typeof ApiKeyMeResponse>;

package/dist/auth/api-keys.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+
+const ApiKeyScope = z.enum(["read", "read_write"]).describe("API key access scope");
+const CreateApiKeyInput = z.object({
+  label: z.string().trim().min(1, "Label is required").max(100).describe("Human label for the key"),
+  scope: ApiKeyScope.default("read"),
+  /** ISO-8601 datetime; omit for a key that never expires. */
+  expiresAt: z.iso.datetime({ offset: true }).optional().describe("Optional expiry (ISO-8601)")
+}).describe("Create a new API key");
+const CreateApiKeyOutput = z.object({
+  id: z.uuid(),
+  label: z.string(),
+  scope: ApiKeyScope,
+  /** Raw secret — returned only once, at creation. */
+  key: z.string()
+}).describe("Newly created API key (raw secret shown once)");
+const ApiKeySummary = z.object({
+  id: z.uuid(),
+  label: z.string(),
+  scope: ApiKeyScope,
+  keyPrefix: z.string(),
+  lastUsedAt: z.string().nullable(),
+  expiresAt: z.string().nullable(),
+  revokedAt: z.string().nullable(),
+  createdAt: z.string()
+});
+const ListApiKeysOutput = z.array(ApiKeySummary).describe("All API keys for the user");
+const ApiKeyMeResponse = z.object({
+  id: z.uuid().describe("User UUID that owns the API key"),
+  role: z.enum(["basic", "pro", "admin"]).describe("User role"),
+  scope: ApiKeyScope,
+  authMethod: z.literal("api_key")
+}).describe("Identity of the caller authenticated via an API key");
+
+export { ApiKeyMeResponse, ApiKeyScope, ApiKeySummary, CreateApiKeyInput, CreateApiKeyOutput, ListApiKeysOutput };

package/dist/auth/index.d.ts

@@ -1,3 +1,4 @@
+export * from './api-keys';
 export * from './entities';
 export * from './payloads';
 export * from './response';

package/dist/auth/index.js

@@ -1,3 +1,4 @@
+export * from './api-keys';
 export * from './entities';
 export * from './payloads';
 export * from './response';

package/dist/auth/payloads.d.ts

@@ -19,13 +19,11 @@ export declare const WalletLoginRequest: z.ZodObject<{
     address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     signature: z.ZodString;
     accessCode: z.ZodOptional<z.ZodString>;
-    clientId: z.ZodString;
 }, z.core.$strip>;
 export declare const EmailLoginRequest: z.ZodObject<{
     method: z.ZodLiteral<"email">;
     email: z.ZodPipe<z.ZodEmail, z.ZodTransform<string, string>>;
     password: z.ZodString;
-    clientId: z.ZodString;
 }, z.core.$strip>;
 export declare const VerifyEmailRequest: z.ZodObject<{
     token: z.ZodString;
@@ -47,12 +45,10 @@ export declare const LoginRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     address: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     signature: z.ZodString;
     accessCode: z.ZodOptional<z.ZodString>;
-    clientId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     method: z.ZodLiteral<"email">;
     email: z.ZodPipe<z.ZodEmail, z.ZodTransform<string, string>>;
     password: z.ZodString;
-    clientId: z.ZodString;
 }, z.core.$strip>], "method">;
 export declare const RefreshTokenRequest: z.ZodObject<{
     refreshToken: z.ZodString;

package/dist/auth/payloads.js

@@ -3,7 +3,6 @@ import { z } from 'zod';
 const EthereumAddress = z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address").transform((val) => val.toLowerCase()).describe("Ethereum wallet address (0x-prefixed, 40 hex chars, lowercase)");
 const Email = z.email("Invalid email address").transform((val) => val.toLowerCase()).describe("Email address (lowercase)");
 const Password = z.string().min(8, "Password must be at least 8 characters").max(128, "Password must be at most 128 characters").describe("Password for authentication");
-const ClientIdCode = z.string().min(1, "clientId is required").max(64, "clientId is too long").describe("Attribution route code (client_ids.code)");
 const AccessCode = z.string().trim().max(64).optional().describe("Optional beta access code");
 const RequestNonceRequest = z.object({
   address: EthereumAddress
@@ -24,14 +23,12 @@ const WalletLoginRequest = z.object({
   method: z.literal("wallet").describe('Must be "wallet" for wallet authentication'),
   address: EthereumAddress,
   signature: z.string().min(1, "Signature is required").describe("Signature of the nonce message"),
-  accessCode: AccessCode,
-  clientId: ClientIdCode
+  accessCode: AccessCode
 }).describe("Wallet-based authentication using nonce signature");
 const EmailLoginRequest = z.object({
   method: z.literal("email").describe('Must be "email" for email authentication'),
   email: Email,
-  password: Password,
-  clientId: ClientIdCode
+  password: Password
 }).describe("Email-based authentication using email and password");
 const VerifyEmailRequest = z.object({
   token: z.string().min(1, "Token is required").describe("Verification token"),

package/dist/bundle.d.ts

@@ -10,6 +10,7 @@ export * from './instrument-precision';
 export * from './leverage';
 export * from './market';
 export * from './misc';
+export * from './notification';
 export * from './order';
 export * from './portfolio';
 export * from './position';
@@ -22,4 +23,5 @@ export * from './tca';
 export * from './trade';
 export * from './trade-accounts';
 export * from './trigger';
+export * from './triggers';
 export * from './users';

package/dist/bundle.js

@@ -10,6 +10,7 @@ export * from './instrument-precision';
 export * from './leverage';
 export * from './market';
 export * from './misc';
+export * from './notification';
 export * from './order';
 export * from './portfolio';
 export * from './position';
@@ -22,4 +23,5 @@ export * from './tca';
 export * from './trade';
 export * from './trade-accounts';
 export * from './trigger';
+export * from './triggers';
 export * from './users';

package/dist/common/client-id.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const ClientIdCode: z.ZodOptional<z.ZodString>;

package/dist/common/client-id.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+const ClientIdCode = z.string().min(1).max(64).optional().describe("Attribution route code (client_ids.code)");
+
+export { ClientIdCode };

package/dist/common/index.d.ts

@@ -1,3 +1,4 @@
 export * from './array';
+export * from './client-id';
 export * from './request';
 export * from './response';

package/dist/common/index.js

@@ -1,3 +1,4 @@
 export * from './array';
+export * from './client-id';
 export * from './request';
 export * from './response';

package/dist/notification/entities.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+export declare const NotificationCategory: z.ZodEnum<{
+    TAKE_PROFIT_HIT: "TAKE_PROFIT_HIT";
+    STOP_LOSS_HIT: "STOP_LOSS_HIT";
+    TRIGGER_ORDER_HIT: "TRIGGER_ORDER_HIT";
+}>;
+export type NotificationCategory = z.infer<typeof NotificationCategory>;
+export declare const NotificationParameters: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"take_profit">;
+    triggerId: z.ZodUUID;
+    positionId: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"stop_loss">;
+    triggerId: z.ZodUUID;
+    positionId: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"trigger_order">;
+    triggerId: z.ZodUUID;
+    positionId: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"default_trigger">;
+    triggerId: z.ZodUUID;
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+    }>;
+}, z.core.$strip>], "type">;
+export type NotificationParameters = z.output<typeof NotificationParameters>;
+export declare const Notification: z.ZodObject<{
+    id: z.ZodUUID;
+    category: z.ZodEnum<{
+        TAKE_PROFIT_HIT: "TAKE_PROFIT_HIT";
+        STOP_LOSS_HIT: "STOP_LOSS_HIT";
+        TRIGGER_ORDER_HIT: "TRIGGER_ORDER_HIT";
+    }>;
+    parameters: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"take_profit">;
+        triggerId: z.ZodUUID;
+        positionId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"stop_loss">;
+        triggerId: z.ZodUUID;
+        positionId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"trigger_order">;
+        triggerId: z.ZodUUID;
+        positionId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"default_trigger">;
+        triggerId: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binance: "binance";
+            bybit: "bybit";
+            okx: "okx";
+            lighter: "lighter";
+        }>;
+    }, z.core.$strip>], "type">;
+    isRead: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type Notification = z.output<typeof Notification>;

package/dist/notification/entities.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { Connector } from '../connector';
+
+const NotificationCategory = z.enum(["TAKE_PROFIT_HIT", "STOP_LOSS_HIT", "TRIGGER_ORDER_HIT"]);
+const TakeProfitNotificationParameters = z.object({
+  type: z.literal("take_profit"),
+  triggerId: z.uuid(),
+  positionId: z.uuid(),
+  connector: Connector
+});
+const StopLossNotificationParameters = z.object({
+  type: z.literal("stop_loss"),
+  triggerId: z.uuid(),
+  positionId: z.uuid(),
+  connector: Connector
+});
+const TriggerOrderNotificationParameters = z.object({
+  type: z.literal("trigger_order"),
+  triggerId: z.uuid(),
+  positionId: z.uuid(),
+  connector: Connector
+});
+const DefaultTriggerNotificationParameters = z.object({
+  type: z.literal("default_trigger"),
+  triggerId: z.uuid(),
+  connector: Connector
+});
+const NotificationParameters = z.discriminatedUnion("type", [
+  TakeProfitNotificationParameters,
+  StopLossNotificationParameters,
+  TriggerOrderNotificationParameters,
+  DefaultTriggerNotificationParameters
+]);
+const Notification = z.object({
+  /**
+   * Notification UUID
+   */
+  id: z.uuid(),
+  /**
+   * What kind of notification this is
+   */
+  category: NotificationCategory,
+  /**
+   * Category-specific display payload
+   */
+  parameters: NotificationParameters,
+  /**
+   * Whether the user has read it
+   */
+  isRead: z.boolean(),
+  /**
+   * Created at timestamp
+   */
+  createdAt: z.string(),
+  /**
+   * Updated at timestamp
+   */
+  updatedAt: z.string()
+});
+
+export { Notification, NotificationCategory, NotificationParameters };

package/dist/notification/index.d.ts

@@ -0,0 +1,4 @@
+export * from './entities';
+export * from './payloads';
+export * from './queries';
+export * from './responses';

package/dist/notification/index.js

@@ -0,0 +1,4 @@
+export * from './entities';
+export * from './payloads';
+export * from './queries';
+export * from './responses';

package/dist/notification/payloads.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+/**
+ * Mark notifications as read. Provide exactly one selector: a single `id`, or a
+ * `timestamp` (epoch ms) to mark every notification created at or before it.
+ */
+export declare const MarkNotificationsReadPayload: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodUUID;
+}, z.core.$strict>, z.ZodObject<{
+    timestamp: z.ZodCoercedNumber<number>;
+}, z.core.$strict>]>;
+export type MarkNotificationsReadPayloadInput = z.input<typeof MarkNotificationsReadPayload>;
+export type MarkNotificationsReadPayload = z.output<typeof MarkNotificationsReadPayload>;
+/**
+ * Mark a single notification unread again.
+ */
+export declare const MarkNotificationUnreadPayload: z.ZodObject<{
+    id: z.ZodUUID;
+}, z.core.$strict>;
+export type MarkNotificationUnreadPayloadInput = z.input<typeof MarkNotificationUnreadPayload>;
+export type MarkNotificationUnreadPayload = z.output<typeof MarkNotificationUnreadPayload>;

package/dist/notification/payloads.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+const MarkNotificationsReadPayload = z.union([
+  z.strictObject({ id: z.uuid() }),
+  z.strictObject({ timestamp: z.coerce.number().int().positive() })
+]);
+const MarkNotificationUnreadPayload = z.strictObject({ id: z.uuid() });
+
+export { MarkNotificationUnreadPayload, MarkNotificationsReadPayload };

package/dist/notification/queries.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const NotificationListParams: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    startDate: z.ZodOptional<z.ZodCoercedDate<Date>>;
+    endDate: z.ZodOptional<z.ZodCoercedDate<Date>>;
+    scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        read: "read";
+        unread: "unread";
+    }>>>;
+}, z.core.$strip>;
+export type NotificationListParamsInput = z.input<typeof NotificationListParams>;
+export type NotificationListParams = z.output<typeof NotificationListParams>;

package/dist/notification/queries.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+
+const NotificationListParams = z.object({
+  /**
+   * The maximum number of notifications to retrieve (newest first).
+   * Matches the V2 engine: max and default are both 100.
+   */
+  limit: z.coerce.number().int().positive().max(100).optional().default(100),
+  /**
+   * Only return notifications created at or after this date.
+   */
+  startDate: z.coerce.date().optional(),
+  /**
+   * Only return notifications created at or before this date.
+   */
+  endDate: z.coerce.date().optional(),
+  /**
+   * Filter by read state: `all` (default), only `read`, or only `unread`.
+   */
+  scope: z.enum(["all", "read", "unread"]).optional().default("all")
+}).refine((data) => !data.startDate || !data.endDate || data.startDate < data.endDate, {
+  message: "startDate must be before endDate"
+});
+
+export { NotificationListParams };

package/dist/notification/responses.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+export declare const NotificationListResponse: z.ZodObject<{
+    notifications: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        category: z.ZodEnum<{
+            TAKE_PROFIT_HIT: "TAKE_PROFIT_HIT";
+            STOP_LOSS_HIT: "STOP_LOSS_HIT";
+            TRIGGER_ORDER_HIT: "TRIGGER_ORDER_HIT";
+        }>;
+        parameters: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"take_profit">;
+            triggerId: z.ZodUUID;
+            positionId: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"stop_loss">;
+            triggerId: z.ZodUUID;
+            positionId: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"trigger_order">;
+            triggerId: z.ZodUUID;
+            positionId: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"default_trigger">;
+            triggerId: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+            }>;
+        }, z.core.$strip>], "type">;
+        isRead: z.ZodBoolean;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type NotificationListResponse = z.output<typeof NotificationListResponse>;
+export declare const MarkNotificationsReadResponse: z.ZodObject<{
+    updated: z.ZodNumber;
+}, z.core.$strip>;
+export type MarkNotificationsReadResponse = z.output<typeof MarkNotificationsReadResponse>;
+export declare const MarkNotificationUnreadResponse: z.ZodObject<{
+    updated: z.ZodNumber;
+}, z.core.$strip>;
+export type MarkNotificationUnreadResponse = z.output<typeof MarkNotificationUnreadResponse>;

package/dist/notification/responses.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { Notification } from './entities';
+
+const NotificationListResponse = z.object({
+  notifications: z.array(Notification)
+});
+const MarkNotificationsReadResponse = z.object({
+  /**
+   * How many notifications were flipped from unread to read.
+   */
+  updated: z.number().int()
+});
+const MarkNotificationUnreadResponse = z.object({
+  /**
+   * How many notifications were flipped from read to unread.
+   */
+  updated: z.number().int()
+});
+
+export { MarkNotificationUnreadResponse, MarkNotificationsReadResponse, NotificationListResponse };

package/dist/rebalance/payloads.d.ts

@@ -7,5 +7,6 @@ export declare const RebalanceManually: z.ZodObject<{
         symbol: z.ZodString;
         weight: z.ZodNumber;
     }, z.core.$strip>>;
+    clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type RebalanceManually = z.output<typeof RebalanceManually>;

package/dist/rebalance/payloads.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ClientIdCode } from '../common/client-id';
 import { RefineWeightingSum, RefineUniqueSymbols } from '../common/refinement';
 import { ExecutionOrderType } from '../execution';
 import { InstrumentId } from '../instrument';
@@ -10,7 +11,11 @@ const RebalanceManually = z.object({
       symbol: InstrumentId,
       weight: z.number().positive({ message: "Weight must be greater than 0" }).max(1, { message: "Weight must be less than 1" })
     })
-  ).superRefine(RefineWeightingSum).superRefine(RefineUniqueSymbols).describe("Array of weightings to rebalance the position")
+  ).superRefine(RefineWeightingSum).superRefine(RefineUniqueSymbols).describe("Array of weightings to rebalance the position"),
+  /**
+   * Attribution route code (client_ids.code)
+   */
+  clientId: ClientIdCode
 });
 
 export { RebalanceManually };

package/dist/schedule/payloads.d.ts

@@ -19,6 +19,7 @@ declare const CreateTWAPOpen: z.ZodObject<{
     }, z.core.$strip>>;
     targetNotional: z.ZodString;
     sliceIntervalSec: z.ZodInt;
+    clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 declare const CreateTWAPClose: z.ZodObject<{
     startAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
@@ -32,6 +33,7 @@ declare const CreateTWAPClose: z.ZodObject<{
     }, z.core.$strip>>;
     positionId: z.ZodUUID;
     sliceIntervalSec: z.ZodInt;
+    clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const CreateSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
     startAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
@@ -53,6 +55,7 @@ export declare const CreateSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>>;
     targetNotional: z.ZodString;
     sliceIntervalSec: z.ZodInt;
+    clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     startAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
     endAt: z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<Date, Date | undefined>>;
@@ -65,6 +68,7 @@ export declare const CreateSchedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>>;
     positionId: z.ZodUUID;
     sliceIntervalSec: z.ZodInt;
+    clientId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "intent">;
 export type CreateTWAPOpen = z.output<typeof CreateTWAPOpen>;
 export type CreateTWAPClose = z.output<typeof CreateTWAPClose>;

package/dist/schedule/payloads.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ClientIdCode } from '../common/client-id';
 import { UnsignedDecimalString, Side } from '../common/schema';
 import { InstrumentId } from '../instrument';
 import { ScheduleSliceMode } from './entities';
@@ -73,7 +74,11 @@ const CreateTWAPOpen = BaseSchedule.safeExtend({
   /**
    * Slice interval in seconds
    */
-  sliceIntervalSec: SliceIntervalSec
+  sliceIntervalSec: SliceIntervalSec,
+  /**
+   * Attribution route code (client_ids.code)
+   */
+  clientId: ClientIdCode
 });
 const CreateTWAPClose = BaseSchedule.safeExtend({
   /**
@@ -99,7 +104,11 @@ const CreateTWAPClose = BaseSchedule.safeExtend({
   /**
    * Slice interval in seconds
    */
-  sliceIntervalSec: SliceIntervalSec
+  sliceIntervalSec: SliceIntervalSec,
+  /**
+   * Attribution route code (client_ids.code)
+   */
+  clientId: ClientIdCode
 });
 const CreateSchedule = z.discriminatedUnion("intent", [CreateTWAPOpen, CreateTWAPClose]);