@deconz-community/directus-extension-ddf-store/src/client.d.ts

Extension for Directus to store DDF files in the database, used only by the Deconz Community

/**
 * This file is automatically generated by the `@indirectus/cli` package.
 * Follow the package's instruction to update this file with the latest schema.
 */

import type * as Directus from "@directus/sdk";

import * as DirectusSDK from "@directus/sdk";

type DirectusSDK = typeof DirectusSDK;

/*
declare module "@directus/sdk" {
  type DirectusAccess<Schema = any> = Directus.MergeCoreCollection<
    Schema,
    "directus_access", {
      id: string;
    }
  >;

  type DirectusPolicies<Schema = any> = Directus.MergeCoreCollection<
    Schema,
    "directus_policies", {
      id: string;
    }
  >;
}
*/

export namespace Types {
  // Internal
  export type Nullable<T> = T | null;
  export type Optional<T> = Nullable<T>;
  export type UnknownType<T> = T | unknown;
  export type PrimaryKey<T> = T;

  // Numbers
  export type BigInteger = number;
  export type Decimal = number;
  export type Float = number;
  export type Integer = number;
  export type Number = number;

  // Buffers
  export type Binary = string;
  export type String = string;
  export type Text = string;

  // Date & Time
  export type Date = string | globalThis.Date;
  export type DateTime = string | globalThis.Date;

  // Geometry
  export namespace Geometry {
    export type LineString = any;
    export type MultiLineString = any;
    export type MultiPoint = any;
    export type MultiPolygon = any;
    export type Point = any;
    export type Polygon = any;
  }

  // Complex
  export type JSON = any;
  export type JSONSchema = any;

  // Others
  export type UUID = string;
  export type Boolean = boolean;
  export type Enum = string;
}

/**
 * All collection types.
 */
export namespace Collections {
  /**
   * The resolved directus activity collection type.
   *
   */
  export type DirectusActivity = Directus.DirectusActivity<System>;

  /**
   * The resolved directus collections collection type.
   *
   */
  export type DirectusCollection = Directus.DirectusCollection<System>;

  /**
   * The resolved directus fields collection type.
   *
   */
  export type DirectusField = Directus.DirectusField<System>;

  /**
   * The resolved directus files collection type.
   *
   */
  export type DirectusFile = Directus.DirectusFile<System>;

  /**
   * The resolved directus folders collection type.
   *
   */
  export type DirectusFolder = Directus.DirectusFolder<System>;

  /**
   * The resolved directus permissions collection type.
   *
   */
  export type DirectusPermission = Directus.DirectusPermission<System>;

  /**
   * The resolved directus presets collection type.
   *
   */
  export type DirectusPreset = Directus.DirectusPreset<System>;

  /**
   * The resolved directus relations collection type.
   *
   */
  export type DirectusRelation = Directus.DirectusRelation<System>;

  /**
   * The resolved directus revisions collection type.
   *
   */
  export type DirectusRevision = Directus.DirectusRevision<System>;

  /**
   * The resolved directus roles collection type.
   *
   */
  export type DirectusRole = Directus.DirectusRole<System>;

  /**
   * The resolved directus settings collection type.
   *
   */
  export type DirectusSettings = Directus.DirectusSettings<System>;

  /**
   * The resolved directus users collection type.
   *
   */
  export type DirectusUser = Directus.DirectusUser<System>;

  /**
   * The resolved directus webhooks collection type.
   *
   */
  export type DirectusWebhook = Directus.DirectusWebhook<System>;

  /**
   * The resolved directus dashboards collection type.
   *
   */
  export type DirectusDashboard = Directus.DirectusDashboard<System>;

  /**
   * The resolved directus panels collection type.
   *
   */
  export type DirectusPanel = Directus.DirectusPanel<System>;

  /**
   * The resolved directus notifications collection type.
   *
   */
  export type DirectusNotification = Directus.DirectusNotification<System>;

  /**
   * The resolved directus shares collection type.
   *
   */
  export type DirectusShare = Directus.DirectusShare<System>;

  /**
   * The resolved directus flows collection type.
   *
   */
  export type DirectusFlow = Directus.DirectusFlow<System>;

  /**
   * The resolved directus operations collection type.
   *
   */
  export type DirectusOperation = Directus.DirectusOperation<System>;

  /**
   * The resolved directus translations collection type.
   *
   */
  export type DirectusTranslation = Directus.DirectusTranslation<System>;

  /**
   * The resolved directus versions collection type.
   *
   */
  export type DirectusVersion = Directus.DirectusVersion<System>;

  /**
   * The resolved directus extensions collection type.
   *
   */
  export type DirectusExtension = Directus.DirectusExtension<System>;

  /**
   * The bundles collection.
   */
  export interface Bundles {
    id: Types.PrimaryKey<Types.String>;
    ddf_uuid: Types.String | Collections.DdfUuids;
    vendor: Types.String;
    product: Types.String;
    version_deconz: Types.String;
    info: Types.Optional<Types.String>;
    user_created: Types.Optional<Types.String | Collections.DirectusUser>;
    date_created: Types.Optional<Types.DateTime>;
    user_updated: Types.Optional<Types.String | Collections.DirectusUser>;
    date_updated: Types.Optional<Types.DateTime>;
    source_last_modified: Types.DateTime;
    file_count: Types.Optional<Types.Integer>;
    content_size: Types.Optional<Types.Integer>;
    content_hash: Types.Optional<Types.String>;
    device_identifiers: Collections.BundlesDeviceIdentifiers[];
    sub_devices: Collections.BundlesSubDevices[];
    signatures: Collections.Signatures[];
    content: Types.Optional<Types.String>;
    deprecation_message: Types.Optional<Types.String>;
  }

  /**
   * The bundles device identifiers collection.
   */
  export interface BundlesDeviceIdentifiers {
    id: Types.PrimaryKey<Types.Integer>;
    bundles_id: Types.Optional<Types.String | Collections.Bundles>;
    device_identifiers_id: Types.Optional<
      Types.String | Collections.DeviceIdentifiers
    >;
  }

  /**
   * The bundles sub devices collection.
   */
  export interface BundlesSubDevices {
    id: Types.PrimaryKey<Types.Integer>;
    bundles_id: Types.Optional<Types.String | Collections.Bundles>;
    sub_devices_type: Types.Optional<Types.String | Collections.SubDevices>;
  }

  /**
   * The ddf uuids collection.
   */
  export interface DdfUuids {
    id: Types.PrimaryKey<Types.String>;
    user_created: Types.Optional<Types.String | Collections.DirectusUser>;
    date_created: Types.Optional<Types.DateTime>;
    user_updated: Types.Optional<Types.String | Collections.DirectusUser>;
    date_updated: Types.Optional<Types.DateTime>;
    expire_at: Types.Optional<Types.DateTime>;
    bundles: Collections.Bundles[];
  }

  /**
   * The device identifiers collection.
   */
  export interface DeviceIdentifiers {
    id: Types.PrimaryKey<Types.String>;
    manufacturer: Types.Optional<Types.String>;
    model: Types.Optional<Types.String>;
    bundles: Collections.BundlesDeviceIdentifiers[];
  }

  /**
   * The signatures collection.
   */
  export interface Signatures {
    id: Types.PrimaryKey<Types.String>;
    bundle: Types.String | Collections.Bundles;
    key: Types.String;
    type: "System" | "User" | Types.String;
  }

  /**
   * The sub devices collection.
   */
  export interface SubDevices {
    type: Types.PrimaryKey<Types.String>;
    name: Types.String;
    endpoint: Types.Optional<"/lights" | "/sensors" | Types.String>;
    bundles: Collections.BundlesSubDevices[];
  }
}

/**
 * System schema extensions.
 */

export interface System {
  /**
   * The definition for the directus activity system collection.
   *
   */
  directus_activity: {}[];

  /**
   * The definition for the directus collections system collection.
   *
   */
  directus_collections: {}[];

  /**
   * The definition for the directus fields system collection.
   *
   */
  directus_fields: {}[];

  /**
   * The definition for the directus files system collection.
   *
   */
  directus_files: {}[];

  /**
   * The definition for the directus folders system collection.
   *
   */
  directus_folders: {}[];

  /**
   * The definition for the directus permissions system collection.
   *
   */
  directus_permissions: {}[];

  /**
   * The definition for the directus presets system collection.
   *
   */
  directus_presets: {}[];

  /**
   * The definition for the directus relations system collection.
   *
   */
  directus_relations: {}[];

  /**
   * The definition for the directus revisions system collection.
   *
   */
  directus_revisions: {}[];

  /**
   * The definition for the directus roles system collection.
   *
   */
  directus_roles: {}[];

  /**
   * The definition for the directus settings system collection.
   *
   */
  directus_settings: {
    private_key_stable: Types.Optional<Types.String>;
    public_key_stable: Types.Optional<Types.String>;
    private_key_beta: Types.Optional<Types.String>;
    public_key_beta: Types.Optional<Types.String>;
    private_key_deprecated: Types.Optional<Types.String>;
    public_key_deprecated: Types.Optional<Types.String>;
  };

  /**
   * The definition for the directus users system collection.
   *
   */
  directus_users: {
    is_contributor: Types.Boolean;
    date_created: Types.Optional<Types.DateTime>;
    public_key: Types.Optional<Types.String>;
    private_key: Types.Optional<Types.String>;
  }[];

  /**
   * The definition for the directus webhooks system collection.
   *
   */
  directus_webhooks: {}[];

  /**
   * The definition for the directus dashboards system collection.
   *
   */
  directus_dashboards: {}[];

  /**
   * The definition for the directus panels system collection.
   *
   */
  directus_panels: {}[];

  /**
   * The definition for the directus notifications system collection.
   *
   */
  directus_notifications: {}[];

  /**
   * The definition for the directus shares system collection.
   *
   */
  directus_shares: {}[];

  /**
   * The definition for the directus flows system collection.
   *
   */
  directus_flows: {}[];

  /**
   * The definition for the directus operations system collection.
   *
   */
  directus_operations: {}[];

  /**
   * The definition for the directus translations system collection.
   *
   */
  directus_translations: {}[];

  /**
   * The definition for the directus versions system collection.
   *
   */
  directus_versions: {}[];

  /**
   * The definition for the directus extensions system collection.
   *
   */
  directus_extensions: {}[];
}

/**
 * Schema definition.
 */
export interface Schema extends System {
  /**
   * The bundles collection.
   */
  bundles: Collections.Bundles[];

  /**
   * The bundles device identifiers collection.
   */
  bundles_device_identifiers: Collections.BundlesDeviceIdentifiers[];

  /**
   * The bundles sub devices collection.
   */
  bundles_sub_devices: Collections.BundlesSubDevices[];

  /**
   * The ddf uuids collection.
   */
  ddf_uuids: Collections.DdfUuids[];

  /**
   * The device identifiers collection.
   */
  device_identifiers: Collections.DeviceIdentifiers[];

  /**
   * The signatures collection.
   */
  signatures: Collections.Signatures[];

  /**
   * The sub devices collection.
   */
  sub_devices: Collections.SubDevices[];
}

export interface TypedCollectionItemsWrapper<Collection extends object> {
  /**
   * Creates many items in the collection.
   */
  create<const Query extends DirectusSDK.Query<Schema, Collection>>(
    items: Partial<Collection>[],
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<Schema, Collection, Query["fields"]>[]
  >;

  /**
   * Read many items from the collection.
   */
  query<const Query extends DirectusSDK.Query<Schema, Collection>>(
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<Schema, Collection, Query["fields"]>[]
  >;

  /**
   * Read the first item from the collection matching the query.
   */
  find<const Query extends DirectusSDK.Query<Schema, Collection>>(
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<Schema, Collection, Query["fields"]>
    | undefined
  >;

  /**
   * Update many items in the collection.
   */
  update<const Query extends DirectusSDK.Query<Schema, Collection[]>>(
    keys: string[] | number[],
    patch: Partial<Collection>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<Schema, Collection, Query["fields"]>[]
  >;

  /**
   * Remove many items in the collection.
   */
  remove<const Query extends DirectusSDK.Query<Schema, Collection>>(
    keys: string[] | number[],
  ): Promise<void>;
}

export interface TypedCollectionItemWrapper<Collection extends object> {
  /**
   * Create a single item in the collection.
   */
  create<const Query extends DirectusSDK.Query<Schema, Collection>>(
    item: Partial<Collection>,
    query?: Query,
  ): Promise<DirectusSDK.ApplyQueryFields<Schema, Collection, Query["fields"]>>;

  /**
   * Read a single item from the collection.
   */
  get<const Query extends DirectusSDK.Query<Schema, Collection>>(
    key: string | number,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<Schema, Collection, Query["fields"]>
    | undefined
  >;

  /**
   * Update a single item from the collection.
   */
  update<const Query extends DirectusSDK.Query<Schema, Collection>>(
    key: string | number,
    patch: Partial<Collection>,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<Schema, Collection, Query["fields"]>
    | undefined
  >;

  /**
   * Remove many items in the collection.
   */
  remove<const Query extends DirectusSDK.Query<Schema, Collection>>(
    key: string | number,
  ): Promise<void>;
}

/**
 * Helper functions
 */

/**
 * Create many bundles items.
 */
export function createBundlesItems<
  const Query extends Directus.Query<Schema, Collections.Bundles[]>,
>(items: Partial<Collections.Bundles>[], query?: Query) {
  return DirectusSDK.createItems<Schema, "bundles", Query>(
    "bundles",
    items,
    query,
  );
}

/**
 * Create a single bundles item.
 */
export function createBundlesItem<
  const Query extends DirectusSDK.Query<Schema, Collections.Bundles[]>, // Is this a mistake? Why []?
>(item: Partial<Collections.Bundles>, query?: Query) {
  return DirectusSDK.createItem<Schema, "bundles", Query>(
    "bundles",
    item,
    query,
  );
}

/**
 * Read many bundles items.
 */
export function readBundlesItems<
  const Query extends Directus.Query<Schema, Collections.Bundles>,
>(query?: Query) {
  return DirectusSDK.readItems<Schema, "bundles", Query>("bundles", query);
}

/**
 * Read many bundles items.
 */
export const listBundles = readBundlesItems;

/**
 * Gets a single known bundles item by id.
 */
export function readBundlesItem<
  const Query extends Directus.Query<Schema, Collections.Bundles>,
>(key: string | number, query?: Query) {
  return DirectusSDK.readItem<Schema, "bundles", Query>("bundles", key, query);
}

/**
 * Gets a single known bundles item by id.
 */
export const readBundles = readBundlesItem;

/**
 * Read many bundles items.
 */
export function updateBundlesItems<
  const Query extends Directus.Query<Schema, Collections.Bundles[]>,
>(
  keys: string[] | number[],
  patch: Partial<Collections.Bundles>,
  query?: Query,
) {
  return DirectusSDK.updateItems<Schema, "bundles", Query>(
    "bundles",
    keys,
    patch,
    query,
  );
}

/**
 * Gets a single known bundles item by id.
 */
export function updateBundlesItem<
  const Query extends Directus.Query<Schema, Collections.Bundles[]>,
>(key: string | number, patch: Partial<Collections.Bundles>, query?: Query) {
  return DirectusSDK.updateItem<Schema, "bundles", Query>(
    "bundles",
    key,
    patch,
    query,
  );
}

/**
 * Deletes many bundles items.
 */
export function deleteBundlesItems<
  const Query extends Directus.Query<Schema, Collections.Bundles[]>,
>(keys: string[] | number[]) {
  return DirectusSDK.deleteItems<Schema, "bundles", Query>("bundles", keys);
}

/**
 * Deletes a single known bundles item by id.
 */
export function deleteBundlesItem(key: string | number) {
  return DirectusSDK.deleteItem<Schema, "bundles">("bundles", key);
}

export class BundlesItems
  implements TypedCollectionItemsWrapper<Collections.Bundles>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Creates many items in the collection.
   */
  async create<
    const Query extends DirectusSDK.Query<Schema, Collections.Bundles>,
  >(
    items: Partial<Collections.Bundles>[],
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<Schema, Collections.Bundles, Query["fields"]>[]
  > {
    return (await this.client.request(
      createBundlesItems(items, query as any),
    )) as any; // Seems like a bug in the SDK.
  }

  /**
   * Read many items from the collection.
   */
  async query<const Query extends Directus.Query<Schema, Collections.Bundles>>(
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<Schema, Collections.Bundles, Query["fields"]>[]
  > {
    return await this.client.request(readBundlesItems(query));
  }

  /**
   * Read the first item from the collection matching the query.
   */
  async find<const Query extends Directus.Query<Schema, Collections.Bundles>>(
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<Schema, Collections.Bundles, Query["fields"]>
    | undefined
  > {
    const items = await this.client.request(
      readBundlesItems({
        ...query,
        limit: 1,
      }),
    );
    return items?.[0] as any; // TODO: fix
  }

  /**
   * Update many items in the collection.
   */
  async update<
    const Query extends Directus.Query<Schema, Collections.Bundles[]>,
  >(
    keys: string[] | number[],
    patch: Partial<Collections.Bundles>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<Schema, Collections.Bundles, Query["fields"]>[]
  > {
    return await this.client.request(updateBundlesItems(keys, patch, query));
  }

  /**
   * Remove many items in the collection.
   */
  async remove<const Query extends Directus.Query<Schema, Collections.Bundles>>(
    keys: string[] | number[],
  ): Promise<void> {}
}

export class BundlesItem
  implements TypedCollectionItemWrapper<Collections.Bundles>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Create a single item in the collection.
   */
  async create<const Query extends Directus.Query<Schema, Collections.Bundles>>(
    item: Partial<Collections.Bundles>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<Schema, Collections.Bundles, Query["fields"]>
  > {
    return (await this.client.request(
      createBundlesItem(item, query as any),
    )) as any;
  }

  /**
   * Read a single item from the collection.
   */
  async get<const Query extends Directus.Query<Schema, Collections.Bundles>>(
    key: string | number,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<Schema, Collections.Bundles, Query["fields"]>
    | undefined
  > {
    return await this.client.request(readBundlesItem(key, query));
  }

  /**
   * Update a single item from the collection.
   */
  async update<const Query extends Directus.Query<Schema, Collections.Bundles>>(
    key: string | number,
    patch: Partial<Collections.Bundles>,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<Schema, Collections.Bundles, Query["fields"]>
    | undefined
  > {
    return (await this.client.request(
      updateBundlesItem(key, patch, query as any),
    )) as any;
  }

  /**
   * Remove many items in the collection.
   */
  async remove<const Query extends Directus.Query<Schema, Collections.Bundles>>(
    key: string | number,
  ): Promise<void> {
    return await this.client.request(deleteBundlesItem(key));
  }
}

/**
 * Create many bundles device identifiers items.
 */
export function createBundlesDeviceIdentifiersItems<
  const Query extends Directus.Query<
    Schema,
    Collections.BundlesDeviceIdentifiers[]
  >,
>(items: Partial<Collections.BundlesDeviceIdentifiers>[], query?: Query) {
  return DirectusSDK.createItems<Schema, "bundles_device_identifiers", Query>(
    "bundles_device_identifiers",
    items,
    query,
  );
}

/**
 * Create a single bundles device identifiers item.
 */
export function createBundlesDeviceIdentifiersItem<
  const Query extends DirectusSDK.Query<
    Schema,
    Collections.BundlesDeviceIdentifiers[]
  >, // Is this a mistake? Why []?
>(item: Partial<Collections.BundlesDeviceIdentifiers>, query?: Query) {
  return DirectusSDK.createItem<Schema, "bundles_device_identifiers", Query>(
    "bundles_device_identifiers",
    item,
    query,
  );
}

/**
 * Read many bundles device identifiers items.
 */
export function readBundlesDeviceIdentifiersItems<
  const Query extends Directus.Query<
    Schema,
    Collections.BundlesDeviceIdentifiers
  >,
>(query?: Query) {
  return DirectusSDK.readItems<Schema, "bundles_device_identifiers", Query>(
    "bundles_device_identifiers",
    query,
  );
}

/**
 * Read many bundles device identifiers items.
 */
export const listBundlesDeviceIdentifiers = readBundlesDeviceIdentifiersItems;

/**
 * Gets a single known bundles device identifiers item by id.
 */
export function readBundlesDeviceIdentifiersItem<
  const Query extends Directus.Query<
    Schema,
    Collections.BundlesDeviceIdentifiers
  >,
>(key: string | number, query?: Query) {
  return DirectusSDK.readItem<Schema, "bundles_device_identifiers", Query>(
    "bundles_device_identifiers",
    key,
    query,
  );
}

/**
 * Gets a single known bundles device identifiers item by id.
 */
export const readBundlesDeviceIdentifiers = readBundlesDeviceIdentifiersItem;

/**
 * Read many bundles device identifiers items.
 */
export function updateBundlesDeviceIdentifiersItems<
  const Query extends Directus.Query<
    Schema,
    Collections.BundlesDeviceIdentifiers[]
  >,
>(
  keys: string[] | number[],
  patch: Partial<Collections.BundlesDeviceIdentifiers>,
  query?: Query,
) {
  return DirectusSDK.updateItems<Schema, "bundles_device_identifiers", Query>(
    "bundles_device_identifiers",
    keys,
    patch,
    query,
  );
}

/**
 * Gets a single known bundles device identifiers item by id.
 */
export function updateBundlesDeviceIdentifiersItem<
  const Query extends Directus.Query<
    Schema,
    Collections.BundlesDeviceIdentifiers[]
  >,
>(
  key: string | number,
  patch: Partial<Collections.BundlesDeviceIdentifiers>,
  query?: Query,
) {
  return DirectusSDK.updateItem<Schema, "bundles_device_identifiers", Query>(
    "bundles_device_identifiers",
    key,
    patch,
    query,
  );
}

/**
 * Deletes many bundles device identifiers items.
 */
export function deleteBundlesDeviceIdentifiersItems<
  const Query extends Directus.Query<
    Schema,
    Collections.BundlesDeviceIdentifiers[]
  >,
>(keys: string[] | number[]) {
  return DirectusSDK.deleteItems<Schema, "bundles_device_identifiers", Query>(
    "bundles_device_identifiers",
    keys,
  );
}

/**
 * Deletes a single known bundles device identifiers item by id.
 */
export function deleteBundlesDeviceIdentifiersItem(key: string | number) {
  return DirectusSDK.deleteItem<Schema, "bundles_device_identifiers">(
    "bundles_device_identifiers",
    key,
  );
}

export class BundlesDeviceIdentifiersItems
  implements TypedCollectionItemsWrapper<Collections.BundlesDeviceIdentifiers>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Creates many items in the collection.
   */
  async create<
    const Query extends DirectusSDK.Query<
      Schema,
      Collections.BundlesDeviceIdentifiers
    >,
  >(
    items: Partial<Collections.BundlesDeviceIdentifiers>[],
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.BundlesDeviceIdentifiers,
      Query["fields"]
    >[]
  > {
    return (await this.client.request(
      createBundlesDeviceIdentifiersItems(items, query as any),
    )) as any; // Seems like a bug in the SDK.
  }

  /**
   * Read many items from the collection.
   */
  async query<
    const Query extends Directus.Query<
      Schema,
      Collections.BundlesDeviceIdentifiers
    >,
  >(
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.BundlesDeviceIdentifiers,
      Query["fields"]
    >[]
  > {
    return await this.client.request(readBundlesDeviceIdentifiersItems(query));
  }

  /**
   * Read the first item from the collection matching the query.
   */
  async find<
    const Query extends Directus.Query<
      Schema,
      Collections.BundlesDeviceIdentifiers
    >,
  >(
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.BundlesDeviceIdentifiers,
        Query["fields"]
      >
    | undefined
  > {
    const items = await this.client.request(
      readBundlesDeviceIdentifiersItems({
        ...query,
        limit: 1,
      }),
    );
    return items?.[0] as any; // TODO: fix
  }

  /**
   * Update many items in the collection.
   */
  async update<
    const Query extends Directus.Query<
      Schema,
      Collections.BundlesDeviceIdentifiers[]
    >,
  >(
    keys: string[] | number[],
    patch: Partial<Collections.BundlesDeviceIdentifiers>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.BundlesDeviceIdentifiers,
      Query["fields"]
    >[]
  > {
    return await this.client.request(
      updateBundlesDeviceIdentifiersItems(keys, patch, query),
    );
  }

  /**
   * Remove many items in the collection.
   */
  async remove<
    const Query extends Directus.Query<
      Schema,
      Collections.BundlesDeviceIdentifiers
    >,
  >(keys: string[] | number[]): Promise<void> {}
}

export class BundlesDeviceIdentifiersItem
  implements TypedCollectionItemWrapper<Collections.BundlesDeviceIdentifiers>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Create a single item in the collection.
   */
  async create<
    const Query extends Directus.Query<
      Schema,
      Collections.BundlesDeviceIdentifiers
    >,
  >(
    item: Partial<Collections.BundlesDeviceIdentifiers>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.BundlesDeviceIdentifiers,
      Query["fields"]
    >
  > {
    return (await this.client.request(
      createBundlesDeviceIdentifiersItem(item, query as any),
    )) as any;
  }

  /**
   * Read a single item from the collection.
   */
  async get<
    const Query extends Directus.Query<
      Schema,
      Collections.BundlesDeviceIdentifiers
    >,
  >(
    key: string | number,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.BundlesDeviceIdentifiers,
        Query["fields"]
      >
    | undefined
  > {
    return await this.client.request(
      readBundlesDeviceIdentifiersItem(key, query),
    );
  }

  /**
   * Update a single item from the collection.
   */
  async update<
    const Query extends Directus.Query<
      Schema,
      Collections.BundlesDeviceIdentifiers
    >,
  >(
    key: string | number,
    patch: Partial<Collections.BundlesDeviceIdentifiers>,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.BundlesDeviceIdentifiers,
        Query["fields"]
      >
    | undefined
  > {
    return (await this.client.request(
      updateBundlesDeviceIdentifiersItem(key, patch, query as any),
    )) as any;
  }

  /**
   * Remove many items in the collection.
   */
  async remove<
    const Query extends Directus.Query<
      Schema,
      Collections.BundlesDeviceIdentifiers
    >,
  >(key: string | number): Promise<void> {
    return await this.client.request(deleteBundlesDeviceIdentifiersItem(key));
  }
}

/**
 * Create many bundles sub devices items.
 */
export function createBundlesSubDevicesItems<
  const Query extends Directus.Query<Schema, Collections.BundlesSubDevices[]>,
>(items: Partial<Collections.BundlesSubDevices>[], query?: Query) {
  return DirectusSDK.createItems<Schema, "bundles_sub_devices", Query>(
    "bundles_sub_devices",
    items,
    query,
  );
}

/**
 * Create a single bundles sub devices item.
 */
export function createBundlesSubDevicesItem<
  const Query extends DirectusSDK.Query<
    Schema,
    Collections.BundlesSubDevices[]
  >, // Is this a mistake? Why []?
>(item: Partial<Collections.BundlesSubDevices>, query?: Query) {
  return DirectusSDK.createItem<Schema, "bundles_sub_devices", Query>(
    "bundles_sub_devices",
    item,
    query,
  );
}

/**
 * Read many bundles sub devices items.
 */
export function readBundlesSubDevicesItems<
  const Query extends Directus.Query<Schema, Collections.BundlesSubDevices>,
>(query?: Query) {
  return DirectusSDK.readItems<Schema, "bundles_sub_devices", Query>(
    "bundles_sub_devices",
    query,
  );
}

/**
 * Read many bundles sub devices items.
 */
export const listBundlesSubDevices = readBundlesSubDevicesItems;

/**
 * Gets a single known bundles sub devices item by id.
 */
export function readBundlesSubDevicesItem<
  const Query extends Directus.Query<Schema, Collections.BundlesSubDevices>,
>(key: string | number, query?: Query) {
  return DirectusSDK.readItem<Schema, "bundles_sub_devices", Query>(
    "bundles_sub_devices",
    key,
    query,
  );
}

/**
 * Gets a single known bundles sub devices item by id.
 */
export const readBundlesSubDevices = readBundlesSubDevicesItem;

/**
 * Read many bundles sub devices items.
 */
export function updateBundlesSubDevicesItems<
  const Query extends Directus.Query<Schema, Collections.BundlesSubDevices[]>,
>(
  keys: string[] | number[],
  patch: Partial<Collections.BundlesSubDevices>,
  query?: Query,
) {
  return DirectusSDK.updateItems<Schema, "bundles_sub_devices", Query>(
    "bundles_sub_devices",
    keys,
    patch,
    query,
  );
}

/**
 * Gets a single known bundles sub devices item by id.
 */
export function updateBundlesSubDevicesItem<
  const Query extends Directus.Query<Schema, Collections.BundlesSubDevices[]>,
>(
  key: string | number,
  patch: Partial<Collections.BundlesSubDevices>,
  query?: Query,
) {
  return DirectusSDK.updateItem<Schema, "bundles_sub_devices", Query>(
    "bundles_sub_devices",
    key,
    patch,
    query,
  );
}

/**
 * Deletes many bundles sub devices items.
 */
export function deleteBundlesSubDevicesItems<
  const Query extends Directus.Query<Schema, Collections.BundlesSubDevices[]>,
>(keys: string[] | number[]) {
  return DirectusSDK.deleteItems<Schema, "bundles_sub_devices", Query>(
    "bundles_sub_devices",
    keys,
  );
}

/**
 * Deletes a single known bundles sub devices item by id.
 */
export function deleteBundlesSubDevicesItem(key: string | number) {
  return DirectusSDK.deleteItem<Schema, "bundles_sub_devices">(
    "bundles_sub_devices",
    key,
  );
}

export class BundlesSubDevicesItems
  implements TypedCollectionItemsWrapper<Collections.BundlesSubDevices>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Creates many items in the collection.
   */
  async create<
    const Query extends DirectusSDK.Query<
      Schema,
      Collections.BundlesSubDevices
    >,
  >(
    items: Partial<Collections.BundlesSubDevices>[],
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.BundlesSubDevices,
      Query["fields"]
    >[]
  > {
    return (await this.client.request(
      createBundlesSubDevicesItems(items, query as any),
    )) as any; // Seems like a bug in the SDK.
  }

  /**
   * Read many items from the collection.
   */
  async query<
    const Query extends Directus.Query<Schema, Collections.BundlesSubDevices>,
  >(
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.BundlesSubDevices,
      Query["fields"]
    >[]
  > {
    return await this.client.request(readBundlesSubDevicesItems(query));
  }

  /**
   * Read the first item from the collection matching the query.
   */
  async find<
    const Query extends Directus.Query<Schema, Collections.BundlesSubDevices>,
  >(
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.BundlesSubDevices,
        Query["fields"]
      >
    | undefined
  > {
    const items = await this.client.request(
      readBundlesSubDevicesItems({
        ...query,
        limit: 1,
      }),
    );
    return items?.[0] as any; // TODO: fix
  }

  /**
   * Update many items in the collection.
   */
  async update<
    const Query extends Directus.Query<Schema, Collections.BundlesSubDevices[]>,
  >(
    keys: string[] | number[],
    patch: Partial<Collections.BundlesSubDevices>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.BundlesSubDevices,
      Query["fields"]
    >[]
  > {
    return await this.client.request(
      updateBundlesSubDevicesItems(keys, patch, query),
    );
  }

  /**
   * Remove many items in the collection.
   */
  async remove<
    const Query extends Directus.Query<Schema, Collections.BundlesSubDevices>,
  >(keys: string[] | number[]): Promise<void> {}
}

export class BundlesSubDevicesItem
  implements TypedCollectionItemWrapper<Collections.BundlesSubDevices>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Create a single item in the collection.
   */
  async create<
    const Query extends Directus.Query<Schema, Collections.BundlesSubDevices>,
  >(
    item: Partial<Collections.BundlesSubDevices>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.BundlesSubDevices,
      Query["fields"]
    >
  > {
    return (await this.client.request(
      createBundlesSubDevicesItem(item, query as any),
    )) as any;
  }

  /**
   * Read a single item from the collection.
   */
  async get<
    const Query extends Directus.Query<Schema, Collections.BundlesSubDevices>,
  >(
    key: string | number,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.BundlesSubDevices,
        Query["fields"]
      >
    | undefined
  > {
    return await this.client.request(readBundlesSubDevicesItem(key, query));
  }

  /**
   * Update a single item from the collection.
   */
  async update<
    const Query extends Directus.Query<Schema, Collections.BundlesSubDevices>,
  >(
    key: string | number,
    patch: Partial<Collections.BundlesSubDevices>,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.BundlesSubDevices,
        Query["fields"]
      >
    | undefined
  > {
    return (await this.client.request(
      updateBundlesSubDevicesItem(key, patch, query as any),
    )) as any;
  }

  /**
   * Remove many items in the collection.
   */
  async remove<
    const Query extends Directus.Query<Schema, Collections.BundlesSubDevices>,
  >(key: string | number): Promise<void> {
    return await this.client.request(deleteBundlesSubDevicesItem(key));
  }
}

/**
 * Create many ddf uuids items.
 */
export function createDdfUuidsItems<
  const Query extends Directus.Query<Schema, Collections.DdfUuids[]>,
>(items: Partial<Collections.DdfUuids>[], query?: Query) {
  return DirectusSDK.createItems<Schema, "ddf_uuids", Query>(
    "ddf_uuids",
    items,
    query,
  );
}

/**
 * Create a single ddf uuids item.
 */
export function createDdfUuidsItem<
  const Query extends DirectusSDK.Query<Schema, Collections.DdfUuids[]>, // Is this a mistake? Why []?
>(item: Partial<Collections.DdfUuids>, query?: Query) {
  return DirectusSDK.createItem<Schema, "ddf_uuids", Query>(
    "ddf_uuids",
    item,
    query,
  );
}

/**
 * Read many ddf uuids items.
 */
export function readDdfUuidsItems<
  const Query extends Directus.Query<Schema, Collections.DdfUuids>,
>(query?: Query) {
  return DirectusSDK.readItems<Schema, "ddf_uuids", Query>("ddf_uuids", query);
}

/**
 * Read many ddf uuids items.
 */
export const listDdfUuids = readDdfUuidsItems;

/**
 * Gets a single known ddf uuids item by id.
 */
export function readDdfUuidsItem<
  const Query extends Directus.Query<Schema, Collections.DdfUuids>,
>(key: string | number, query?: Query) {
  return DirectusSDK.readItem<Schema, "ddf_uuids", Query>(
    "ddf_uuids",
    key,
    query,
  );
}

/**
 * Gets a single known ddf uuids item by id.
 */
export const readDdfUuids = readDdfUuidsItem;

/**
 * Read many ddf uuids items.
 */
export function updateDdfUuidsItems<
  const Query extends Directus.Query<Schema, Collections.DdfUuids[]>,
>(
  keys: string[] | number[],
  patch: Partial<Collections.DdfUuids>,
  query?: Query,
) {
  return DirectusSDK.updateItems<Schema, "ddf_uuids", Query>(
    "ddf_uuids",
    keys,
    patch,
    query,
  );
}

/**
 * Gets a single known ddf uuids item by id.
 */
export function updateDdfUuidsItem<
  const Query extends Directus.Query<Schema, Collections.DdfUuids[]>,
>(key: string | number, patch: Partial<Collections.DdfUuids>, query?: Query) {
  return DirectusSDK.updateItem<Schema, "ddf_uuids", Query>(
    "ddf_uuids",
    key,
    patch,
    query,
  );
}

/**
 * Deletes many ddf uuids items.
 */
export function deleteDdfUuidsItems<
  const Query extends Directus.Query<Schema, Collections.DdfUuids[]>,
>(keys: string[] | number[]) {
  return DirectusSDK.deleteItems<Schema, "ddf_uuids", Query>("ddf_uuids", keys);
}

/**
 * Deletes a single known ddf uuids item by id.
 */
export function deleteDdfUuidsItem(key: string | number) {
  return DirectusSDK.deleteItem<Schema, "ddf_uuids">("ddf_uuids", key);
}

export class DdfUuidsItems
  implements TypedCollectionItemsWrapper<Collections.DdfUuids>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Creates many items in the collection.
   */
  async create<
    const Query extends DirectusSDK.Query<Schema, Collections.DdfUuids>,
  >(
    items: Partial<Collections.DdfUuids>[],
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.DdfUuids,
      Query["fields"]
    >[]
  > {
    return (await this.client.request(
      createDdfUuidsItems(items, query as any),
    )) as any; // Seems like a bug in the SDK.
  }

  /**
   * Read many items from the collection.
   */
  async query<const Query extends Directus.Query<Schema, Collections.DdfUuids>>(
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.DdfUuids,
      Query["fields"]
    >[]
  > {
    return await this.client.request(readDdfUuidsItems(query));
  }

  /**
   * Read the first item from the collection matching the query.
   */
  async find<const Query extends Directus.Query<Schema, Collections.DdfUuids>>(
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.DdfUuids,
        Query["fields"]
      >
    | undefined
  > {
    const items = await this.client.request(
      readDdfUuidsItems({
        ...query,
        limit: 1,
      }),
    );
    return items?.[0] as any; // TODO: fix
  }

  /**
   * Update many items in the collection.
   */
  async update<
    const Query extends Directus.Query<Schema, Collections.DdfUuids[]>,
  >(
    keys: string[] | number[],
    patch: Partial<Collections.DdfUuids>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.DdfUuids,
      Query["fields"]
    >[]
  > {
    return await this.client.request(updateDdfUuidsItems(keys, patch, query));
  }

  /**
   * Remove many items in the collection.
   */
  async remove<
    const Query extends Directus.Query<Schema, Collections.DdfUuids>,
  >(keys: string[] | number[]): Promise<void> {}
}

export class DdfUuidsItem
  implements TypedCollectionItemWrapper<Collections.DdfUuids>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Create a single item in the collection.
   */
  async create<
    const Query extends Directus.Query<Schema, Collections.DdfUuids>,
  >(
    item: Partial<Collections.DdfUuids>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<Schema, Collections.DdfUuids, Query["fields"]>
  > {
    return (await this.client.request(
      createDdfUuidsItem(item, query as any),
    )) as any;
  }

  /**
   * Read a single item from the collection.
   */
  async get<const Query extends Directus.Query<Schema, Collections.DdfUuids>>(
    key: string | number,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.DdfUuids,
        Query["fields"]
      >
    | undefined
  > {
    return await this.client.request(readDdfUuidsItem(key, query));
  }

  /**
   * Update a single item from the collection.
   */
  async update<
    const Query extends Directus.Query<Schema, Collections.DdfUuids>,
  >(
    key: string | number,
    patch: Partial<Collections.DdfUuids>,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.DdfUuids,
        Query["fields"]
      >
    | undefined
  > {
    return (await this.client.request(
      updateDdfUuidsItem(key, patch, query as any),
    )) as any;
  }

  /**
   * Remove many items in the collection.
   */
  async remove<
    const Query extends Directus.Query<Schema, Collections.DdfUuids>,
  >(key: string | number): Promise<void> {
    return await this.client.request(deleteDdfUuidsItem(key));
  }
}

/**
 * Create many device identifiers items.
 */
export function createDeviceIdentifiersItems<
  const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers[]>,
>(items: Partial<Collections.DeviceIdentifiers>[], query?: Query) {
  return DirectusSDK.createItems<Schema, "device_identifiers", Query>(
    "device_identifiers",
    items,
    query,
  );
}

/**
 * Create a single device identifiers item.
 */
export function createDeviceIdentifiersItem<
  const Query extends DirectusSDK.Query<
    Schema,
    Collections.DeviceIdentifiers[]
  >, // Is this a mistake? Why []?
>(item: Partial<Collections.DeviceIdentifiers>, query?: Query) {
  return DirectusSDK.createItem<Schema, "device_identifiers", Query>(
    "device_identifiers",
    item,
    query,
  );
}

/**
 * Read many device identifiers items.
 */
export function readDeviceIdentifiersItems<
  const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers>,
>(query?: Query) {
  return DirectusSDK.readItems<Schema, "device_identifiers", Query>(
    "device_identifiers",
    query,
  );
}

/**
 * Read many device identifiers items.
 */
export const listDeviceIdentifiers = readDeviceIdentifiersItems;

/**
 * Gets a single known device identifiers item by id.
 */
export function readDeviceIdentifiersItem<
  const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers>,
>(key: string | number, query?: Query) {
  return DirectusSDK.readItem<Schema, "device_identifiers", Query>(
    "device_identifiers",
    key,
    query,
  );
}

/**
 * Gets a single known device identifiers item by id.
 */
export const readDeviceIdentifiers = readDeviceIdentifiersItem;

/**
 * Read many device identifiers items.
 */
export function updateDeviceIdentifiersItems<
  const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers[]>,
>(
  keys: string[] | number[],
  patch: Partial<Collections.DeviceIdentifiers>,
  query?: Query,
) {
  return DirectusSDK.updateItems<Schema, "device_identifiers", Query>(
    "device_identifiers",
    keys,
    patch,
    query,
  );
}

/**
 * Gets a single known device identifiers item by id.
 */
export function updateDeviceIdentifiersItem<
  const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers[]>,
>(
  key: string | number,
  patch: Partial<Collections.DeviceIdentifiers>,
  query?: Query,
) {
  return DirectusSDK.updateItem<Schema, "device_identifiers", Query>(
    "device_identifiers",
    key,
    patch,
    query,
  );
}

/**
 * Deletes many device identifiers items.
 */
export function deleteDeviceIdentifiersItems<
  const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers[]>,
>(keys: string[] | number[]) {
  return DirectusSDK.deleteItems<Schema, "device_identifiers", Query>(
    "device_identifiers",
    keys,
  );
}

/**
 * Deletes a single known device identifiers item by id.
 */
export function deleteDeviceIdentifiersItem(key: string | number) {
  return DirectusSDK.deleteItem<Schema, "device_identifiers">(
    "device_identifiers",
    key,
  );
}

export class DeviceIdentifiersItems
  implements TypedCollectionItemsWrapper<Collections.DeviceIdentifiers>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Creates many items in the collection.
   */
  async create<
    const Query extends DirectusSDK.Query<
      Schema,
      Collections.DeviceIdentifiers
    >,
  >(
    items: Partial<Collections.DeviceIdentifiers>[],
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.DeviceIdentifiers,
      Query["fields"]
    >[]
  > {
    return (await this.client.request(
      createDeviceIdentifiersItems(items, query as any),
    )) as any; // Seems like a bug in the SDK.
  }

  /**
   * Read many items from the collection.
   */
  async query<
    const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers>,
  >(
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.DeviceIdentifiers,
      Query["fields"]
    >[]
  > {
    return await this.client.request(readDeviceIdentifiersItems(query));
  }

  /**
   * Read the first item from the collection matching the query.
   */
  async find<
    const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers>,
  >(
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.DeviceIdentifiers,
        Query["fields"]
      >
    | undefined
  > {
    const items = await this.client.request(
      readDeviceIdentifiersItems({
        ...query,
        limit: 1,
      }),
    );
    return items?.[0] as any; // TODO: fix
  }

  /**
   * Update many items in the collection.
   */
  async update<
    const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers[]>,
  >(
    keys: string[] | number[],
    patch: Partial<Collections.DeviceIdentifiers>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.DeviceIdentifiers,
      Query["fields"]
    >[]
  > {
    return await this.client.request(
      updateDeviceIdentifiersItems(keys, patch, query),
    );
  }

  /**
   * Remove many items in the collection.
   */
  async remove<
    const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers>,
  >(keys: string[] | number[]): Promise<void> {}
}

export class DeviceIdentifiersItem
  implements TypedCollectionItemWrapper<Collections.DeviceIdentifiers>
{
  /**
   *
   */
  constructor(
    private client: Directus.DirectusClient<Schema> &
      Directus.RestClient<Schema>,
  ) {}

  /**
   * Create a single item in the collection.
   */
  async create<
    const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers>,
  >(
    item: Partial<Collections.DeviceIdentifiers>,
    query?: Query,
  ): Promise<
    DirectusSDK.ApplyQueryFields<
      Schema,
      Collections.DeviceIdentifiers,
      Query["fields"]
    >
  > {
    return (await this.client.request(
      createDeviceIdentifiersItem(item, query as any),
    )) as any;
  }

  /**
   * Read a single item from the collection.
   */
  async get<
    const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers>,
  >(
    key: string | number,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.DeviceIdentifiers,
        Query["fields"]
      >
    | undefined
  > {
    return await this.client.request(readDeviceIdentifiersItem(key, query));
  }

  /**
   * Update a single item from the collection.
   */
  async update<
    const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers>,
  >(
    key: string | number,
    patch: Partial<Collections.DeviceIdentifiers>,
    query?: Query,
  ): Promise<
    | DirectusSDK.ApplyQueryFields<
        Schema,
        Collections.DeviceIdentifiers,
        Query["fields"]
      >
    | undefined
  > {
    return (await this.client.request(
      updateDeviceIdentifiersItem(key, patch, query as any),
    )) as any;
  }

  /**
   * Remove many items in the collection.
   */
  async remove<
    const Query extends Directus.Query<Schema, Collections.DeviceIdentifiers>,
  >(key: string | number): Promise<void> {
    return await this.client.request(deleteDeviceIdentifiersItem(key));
  }
}

/**
 * Create many signatures items.
 */
export function createSignaturesItems<
  const Query extends Directus.Query<Schema, Collections.Signatures[]>,
>(items: Partial<Collections.Signatures>[], query?: Query) {
  return DirectusSDK.createItems<Schema, "signatures", Query>(
    "signatures",
    items,
    query,
  );
}

/**
 * Create a single signatures item.
 */
export function createSignaturesItem<
  const Query extends DirectusSDK.Query<Schema, Collections.Signatures[