feat: Add typescript declaration files

src/acceltween/index.d.ts

@@ -0,0 +1 @@
+export * from './src/Shared/AccelTween';

src/acceltween/src/Shared/AccelTween.d.ts

@@ -0,0 +1,15 @@
+type AccelTween = {
+  p: number;
+  v: number;
+  a: number;
+  t: number;
+  rtime: number;
+  pt: number;
+};
+
+interface AccelTweenConstructor {
+  readonly ClassName: 'AccelTween';
+  new (maxAcceleration?: number): AccelTween;
+}
+
+export const AccelTween: AccelTweenConstructor;

src/accessorytypeutils/index.d.ts

@@ -0,0 +1 @@
+export * from './src/Shared/AccessoryTypeUtils';

src/accessorytypeutils/src/Shared/AccessoryTypeUtils.d.ts

@@ -0,0 +1,12 @@
+export namespace AccessoryTypeUtils {
+  function tryGetAccessoryType(
+    avatarAssetType: Enum.AvatarAssetType
+  ): LuaTuple<[accessoryType?: Enum.AccessoryType, err?: string]>;
+  function getAccessoryTypeFromName(accessoryType: string): Enum.AccessoryType;
+  function convertAssetTypeIdToAssetType(
+    assetTypeId: number
+  ): Enum.AssetType | undefined;
+  function convertAssetTypeIdToAvatarAssetType(
+    avatarAssetTypeId: number
+  ): Enum.AvatarAssetType | undefined;
+}

src/actionmanager/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/Client/ActionManager';
+export * from './src/Client/BaseAction';

src/actionmanager/src/Client/ActionManager.d.ts

@@ -0,0 +1,23 @@
+import { Signal } from '@quenty/signal';
+import { ValueObject } from '@quenty/valueobject';
+import { BaseAction } from './BaseAction';
+
+interface ActionManager {
+  ActiveAction: ValueObject<BaseAction | undefined>;
+  ActionAdded: Signal<BaseAction>;
+  StopCurrentAction(): void;
+  ActivateAction<T extends BaseAction>(action: T, ...args: unknown[]): void;
+  GetAction(name: string): BaseAction | undefined;
+  GetActions(): BaseAction[];
+  AddAction(action: BaseAction): void;
+  Destroy(): void;
+}
+
+interface ActionManagerConstructor {
+  readonly ClassName: 'ActionManager';
+  new (parent?: Instance): ActionManager;
+
+  ExtraPixels: 2;
+}
+
+export const ActionManager: ActionManagerConstructor;

src/actionmanager/src/Client/BaseAction.d.ts

@@ -0,0 +1,40 @@
+import { EnabledMixin } from '@quenty/enabledmixin';
+import { Maid } from '@quenty/maid';
+import { Signal } from '@quenty/signal';
+import { ValueObject } from '@quenty/valueobject';
+
+export interface ActionData {
+  Name: string;
+  Shortcuts?: (Enum.KeyCode | Enum.UserInputType)[];
+}
+
+interface BaseAction<T = void> extends EnabledMixin {
+  Activated: Signal<
+    [
+      actionMaid: Maid,
+      ...activateData: T extends void ? [] : T extends unknown[] ? T : [T]
+    ]
+  >;
+  Deactivated: Signal;
+  IsActivatedValue: ValueObject<boolean>;
+  GetName(): string;
+  GetData(): ActionData;
+  ToggleActivate(
+    ...activateData: T extends void ? [] : T extends unknown[] ? T : [T]
+  ): void;
+  IsActive(): boolean;
+  Deactivate(): void;
+  Activate(
+    ...activateData: T extends void ? [] : T extends unknown[] ? T : [T]
+  ): void;
+  Destroy(): void;
+}
+
+interface BaseActionConstructor {
+  readonly ClassName: 'BaseAction';
+  new <T extends unknown[] | void = void>(
+    actionData: ActionData
+  ): BaseAction<T>;
+}
+
+export const BaseAction: BaseActionConstructor;

src/adorneeboundingbox/index.d.ts

@@ -0,0 +1,4 @@
+export * from './src/Shared/AdorneeBoundingBox';
+export * from './src/Shared/AdorneeModelBoundingBox';
+export * from './src/Shared/AdorneePartBoundingBox';
+export * from './src/Shared/RxPartBoundingBoxUtils';

src/adorneeboundingbox/src/Shared/AdorneeBoundingBox.d.ts

@@ -0,0 +1,24 @@
+import { BaseObject } from '@quenty/baseobject';
+import { Observable } from '@quenty/rx';
+
+interface BoundingBoxData {
+  CFrame: CFrame;
+  Size: Vector3;
+}
+
+interface AdorneeBoundingBox extends BaseObject {
+  SetAdornee(adornee: Instance | undefined): () => void;
+  ObserveBoundingBox(): Observable<BoundingBoxData>;
+  GetBoundingBox(): BoundingBoxData | undefined;
+  ObserveCFrame(): Observable<CFrame | undefined>;
+  GetCFrame(): CFrame | undefined;
+  ObserveSize(): Observable<Vector3 | undefined>;
+  GetSize(): Vector3 | undefined;
+}
+
+interface AdorneeBoundingBoxConstructor {
+  readonly ClassName: 'AdorneeBoundingBox';
+  new (initialAdornee?: Instance): AdorneeBoundingBox;
+}
+
+export const AdorneeBoundingBox: AdorneeBoundingBoxConstructor;

src/adorneeboundingbox/src/Shared/AdorneeModelBoundingBox.d.ts

@@ -0,0 +1,14 @@
+import { BaseObject } from '@quenty/baseobject';
+import { Observable } from '@quenty/rx';
+
+interface AdorneeModelBoundingBox extends BaseObject {
+  ObserveCFrame(): Observable<CFrame>;
+  ObserveSize(): Observable<Vector3>;
+}
+
+interface AdorneeModelBoundingBoxConstructor {
+  readonly ClassName: 'AdorneeModelBoundingBox';
+  new (model: Model): AdorneeModelBoundingBox;
+}
+
+export const AdorneeModelBoundingBox: AdorneeModelBoundingBoxConstructor;

src/adorneeboundingbox/src/Shared/AdorneePartBoundingBox.d.ts

@@ -0,0 +1,14 @@
+import { BaseObject } from '@quenty/baseobject';
+import { Observable } from '@quenty/rx';
+
+interface AdorneePartBoundingBox extends BaseObject {
+  ObserveCFrame(): Observable<CFrame>;
+  ObserveSize(): Observable<Vector3>;
+}
+
+interface AdorneePartBoundingBoxConstructor {
+  readonly ClassName: 'AdorneePartBoundingBox';
+  new (part: BasePart): AdorneePartBoundingBox;
+}
+
+export const AdorneePartBoundingBox: AdorneePartBoundingBoxConstructor;

src/adorneeboundingbox/src/Shared/RxPartBoundingBoxUtils.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from '@quenty/rx';
+
+export namespace RxPartBoundingBoxUtils {
+  function observePartCFrame(part: BasePart): Observable<CFrame>;
+}

src/adorneedata/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/Shared/AdorneeData';
+export * from './src/Shared/AdorneeDataEntry';
+export * from './src/Shared/AdorneeDataValue';

src/adorneedata/src/Shared/AdorneeData.d.ts

@@ -0,0 +1,44 @@
+import { AttributeValue } from '@quenty/attributeutils';
+import { Observable } from '@quenty/rx';
+import { AdorneeDataValue } from './AdorneeDataValue';
+import { AdorneeDataEntry } from './AdorneeDataEntry';
+
+export type ToAdorneeEntries<T extends Record<PropertyKey, unknown> | unknown> =
+  T extends unknown
+    ? {}
+    : {
+        [K in keyof T]: Readonly<
+          T[K] extends AdorneeDataEntry<infer V>
+            ? AdorneeDataEntry<V>
+            : T[K] extends Record<PropertyKey, unknown>
+            ? never
+            : AdorneeDataEntry<T[K]>
+        >;
+      };
+
+type AdorneeData<T extends Record<PropertyKey, unknown>> =
+  ToAdorneeEntries<T> & {
+    IsStrictData(
+      data: unknown
+    ): LuaTuple<[success: boolean, errorMessage: string]>;
+    CreateStrictData<Y extends T>(data: Y): Readonly<Y>;
+    CreateFullData(data: Partial<T>): Readonly<T>;
+    CreateData<Y extends Partial<T>>(data: Y): Readonly<Y>;
+    Observe(adornee: Instance): Observable<T>;
+    Create(adornee: Instance): AdorneeDataValue<T>;
+    Get(adornee: Instance): Readonly<T>;
+    Set(adornee: Instance, data: Partial<T>): void;
+    Unset(adornee: Instance): void;
+    SetStrict(adornee: Instance, data: T): void;
+    InitAttributes(adornee: Instance, data: Partial<T> | undefined): void;
+    GetStrictTInterface(): (data: unknown) => data is T;
+    GetTInterface(): (data: unknown) => data is Partial<T>;
+    IsData(data: unknown): data is Partial<T>;
+  };
+
+interface AdorneeDataConstructor {
+  readonly ClassName: 'AdorneeData';
+  new <T extends Record<PropertyKey, unknown>>(prototype: T): AdorneeData<T>;
+}
+
+export const AdorneeData: AdorneeDataConstructor;

src/adorneedata/src/Shared/AdorneeDataEntry.d.ts

@@ -0,0 +1,39 @@
+import { AttributeValue } from '@quenty/attributeutils';
+import { Observable } from '@quenty/rx';
+import { ValueObjectLike } from '@quenty/valueobject';
+
+type ValueInterface = (
+  value: unknown
+) =>
+  | boolean
+  | (
+      | LuaTuple<[success: true, errorMessage: undefined]>
+      | LuaTuple<[success: false, errorMessage: string]>
+    );
+
+type AdorneeDataEntry<T> = {
+  Create(adornee: Instance): AttributeValue<T>;
+  Observe(adornee: Instance): Observable<T>;
+  Get(adornee: Instance): T;
+  Set(adornee: Instance, value: T): void;
+  GetDefaultValue(): T | undefined;
+  GetStrictInterface(): ValueInterface;
+  IsValid(value: unknown): value is T;
+};
+
+interface AdorneeDataEntryConstructor {
+  readonly ClassName: 'AdorneeDataEntry';
+  new <T extends keyof CheckableTypes | ValueInterface>(
+    interface: T,
+    createValueObject: (adornee: Instance) => ValueObjectLike<T extends (value: unknown) => value is infer V ? V : CheckableTypes[T]>,
+    defaultValue?: T extends (value: unknown) => value is infer V ? NonNullable<V> : CheckableTypes[T]
+  ): AdorneeDataEntry<T extends (value: unknown) => value is infer V ? V : CheckableTypes[T]>;
+
+  isAdorneeDataEntry: (value: unknown) => value is AdorneeDataEntry<unknown>;
+  optionalAttribute: (
+    interface: string | ValueInterface,
+    name: string
+  ) => AdorneeDataEntry<unknown>;
+}
+
+export const AdorneeDataEntry: AdorneeDataEntryConstructor;

src/adorneedata/src/Shared/AdorneeDataValue.d.ts

@@ -0,0 +1,35 @@
+import { AdorneeData, AdorneeDataEntry } from '@quenty/adorneedata';
+import { AttributeValue } from '@quenty/attributeutils';
+import { Observable } from '@quenty/rx';
+import { Signal } from '@quenty/signal';
+import { ValueObjectLike } from '@quenty/valueobject';
+
+type MapToValues<T extends Record<PropertyKey, unknown> | unknown> =
+  T extends Record<PropertyKey, unknown>
+    ? Readonly<{
+        [K in keyof T]: T[K] extends AdorneeDataEntry<infer V>
+          ? ValueObjectLike<V>
+          : AttributeValue<T[K]>;
+      }>
+    : {};
+
+export type FromAdorneeData<T extends AdorneeData<unknown>> =
+      T extends AdorneeData<infer U> ? AdorneeDataValue<U> : never;
+
+type AdorneeDataValue<T> = MapToValues<T> & {
+  Value: T;
+  readonly Changed: Signal<T>;
+  Observe(): Observable<T>;
+};
+
+interface AdorneeDataValueConstructor {
+  readonly ClassName: 'AdorneeDataValue';
+  new <T>(
+    adornee: Instance,
+    prototype: Record<PropertyKey, unknown>
+  ): AdorneeDataValue<T>;
+
+  isAdorneeDataValue: (value: unknown) => value is AdorneeDataValue<unknown>;
+}
+
+export const AdorneeDataValue: AdorneeDataValueConstructor;

src/adorneeutils/index.d.ts

@@ -0,0 +1 @@
+export * from './src/Shared/AdorneeUtils';

src/adorneeutils/src/Shared/AdorneeUtils.d.ts

@@ -0,0 +1,14 @@
+export namespace AdorneeUtils {
+  function getCenter(adornee: Instance): Vector3 | undefined;
+  function getBoundingBox(
+    adornee: Instance
+  ): LuaTuple<[cframe?: CFrame, size?: Vector3]>;
+  function isPartOfAdornee(adornee: Instance, part: BasePart): boolean;
+  function getParts(adornee: Instance): BasePart[];
+  function getAlignedSize(adornee: Instance): Vector3 | undefined;
+  function getPartCFrame(adornee: Instance): CFrame | undefined;
+  function getPartPosition(adornee: Instance): Vector3 | undefined;
+  function getPartVelocity(adornee: Instance): Vector3 | undefined;
+  function getPart(adornee: Instance): BasePart | undefined;
+  function getRenderAdornee(adornee: Instance): Instance | undefined;
+}

src/adorneevalue/index.d.ts

@@ -0,0 +1 @@
+export * from './src/Shared/AdorneeValue';

src/adorneevalue/package.json

@@ -30,6 +30,7 @@
     "@quenty/blend": "file:../blend",
     "@quenty/loader": "file:../loader",
     "@quenty/maid": "file:../maid",
+    "@quenty/rx": "file:../rx",
     "@quenty/signal": "file:../signal",
     "@quenty/valueobject": "file:../valueobject"
   },

src/adorneevalue/src/Shared/AdorneeValue.d.ts

@@ -0,0 +1,40 @@
+import { Signal } from '@quenty/signal';
+import { BaseObject } from '@quenty/baseobject';
+import { Observable } from '@quenty/rx';
+
+type AdorneeValueOption = Instance | CFrame | Vector3;
+
+interface AdorneeValue extends BaseObject {
+  Value: AdorneeValueOption | undefined;
+  readonly Changed: Signal<
+    [new: AdorneeValueOption | undefined, old: AdorneeValueOption | undefined]
+  >;
+  GetAdornee(): AdorneeValueOption | undefined;
+  Observe(): Observable<AdorneeValueOption | undefined>;
+  ObserveBottomCFrame(): Observable<CFrame | undefined>;
+  ObserveCenterPosition(): Observable<Vector3 | undefined>;
+  GetCenterPosition(): Vector3 | undefined;
+  ObserveRadius(): Observable<number | undefined>;
+  GetRadius(): number | undefined;
+  ObservePositionTowards(
+    observeTargetPosition: Observable<Vector3>,
+    observeRadius?: Observable<number>
+  ): Observable<Vector3 | undefined>;
+  GetPositionTowards(
+    target: Vector3,
+    radius?: number,
+    center?: Vector3
+  ): Vector3 | undefined;
+  ObserveAttachmentParent(): Observable<BasePart | Terrain | undefined>;
+  RenderPositionAttachment(props?: {
+    WorldPosition?: Vector3;
+    Name?: string;
+  }): Observable<Instance | undefined>;
+}
+
+interface AdorneeValueConstructor {
+  readonly ClassName: 'AdorneeValue';
+  new (): AdorneeValue;
+}
+
+export const AdorneeValue: AdorneeValueConstructor;

src/aggregator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/Shared/Aggregator';
+export * from './src/Shared/RateAggregator';

src/aggregator/src/Shared/Aggregator.d.ts

@@ -0,0 +1,19 @@
+import { BaseObject } from '@quenty/baseobject';
+import { Promise } from '@quenty/promise';
+import { Observable } from '@quenty/rx';
+
+interface Aggregator<T> extends BaseObject {
+  SetMaxBatchSize(maxBatchSize: number): void;
+  Promise(id: number): Promise<T>;
+  Observe(id: number): Observable<T>;
+}
+
+interface AggregatorConstructor {
+  readonly ClassName: 'Aggregator';
+  new <T>(
+    debugName: string,
+    promiseBulkQuery: (idList: number[]) => Promise<T>
+  ): Aggregator<T>;
+}
+
+export const Aggregator: AggregatorConstructor;

src/aggregator/src/Shared/RateAggregator.d.ts

@@ -0,0 +1,16 @@
+import { BaseObject } from '@quenty/baseobject';
+import { Promise } from '@quenty/promise';
+
+interface RateAggregator<A extends unknown[], R> extends BaseObject {
+  SetMaxRequestsPerSecond(maxRequestsPerSecond: number): void;
+  Promise(...args: A): Promise<R>;
+}
+
+interface RateAggregatorConstructor {
+  readonly ClassName: 'RateAggregator';
+  new <A extends unknown[], R>(
+    promiseQuery: (...args: A) => Promise<R>
+  ): RateAggregator<A, R>;
+}
+
+export const RateAggregator: RateAggregatorConstructor;