declare module '@ember/object/proxy' {
    /**
    @module @ember/object/proxy
    */
    import { FrameworkObject } from "@ember/object/-internals";
    import { _ProxyMixin } from "@ember/-internals/runtime";
    /**
      `ObjectProxy` forwards all properties not defined by the proxy itself
      to a proxied `content` object.

      ```javascript
      import EmberObject from '@ember/object';
      import ObjectProxy from '@ember/object/proxy';

      let exampleObject = EmberObject.create({
        name: 'Foo'
      });

      let exampleProxy = ObjectProxy.create({
        content: exampleObject
      });

      // Access and change existing properties
      exampleProxy.get('name');          // 'Foo'
      exampleProxy.set('name', 'Bar');
      exampleObject.get('name');         // 'Bar'

      // Create new 'description' property on `exampleObject`
      exampleProxy.set('description', 'Foo is a whizboo baz');
      exampleObject.get('description');  // 'Foo is a whizboo baz'
      ```

      While `content` is unset, setting a property to be delegated will throw an
      Error.

      ```javascript
      import ObjectProxy from '@ember/object/proxy';

      let exampleProxy = ObjectProxy.create({
        content: null,
        flag: null
      });
      exampleProxy.set('flag', true);
      exampleProxy.get('flag');         // true
      exampleProxy.get('foo');          // undefined
      exampleProxy.set('foo', 'data');  // throws Error
      ```

      Delegated properties can be bound to and will change when content is updated.

      Computed properties on the proxy itself can depend on delegated properties.

      ```javascript
      import { computed } from '@ember/object';
      import ObjectProxy from '@ember/object/proxy';

      class ProxyWithComputedProperty extends ObjectProxy {
        @computed('firstName', 'lastName')
        get fullName() {
          var firstName = this.get('firstName'),
              lastName = this.get('lastName');
          if (firstName && lastName) {
            return firstName + ' ' + lastName;
          }
          return firstName || lastName;
        }
      }

      let exampleProxy = ProxyWithComputedProperty.create();

      exampleProxy.get('fullName');  // undefined
      exampleProxy.set('content', {
        firstName: 'Tom', lastName: 'Dale'
      }); // triggers property change for fullName on proxy

      exampleProxy.get('fullName');  // 'Tom Dale'
      ```

      @class ObjectProxy
      @extends EmberObject
      @uses Ember.ProxyMixin
      @public
    */
    interface ObjectProxy<Content = unknown> extends _ProxyMixin<Content> {
        get<K extends keyof Content>(keyName: K): Content[K];
        get<K extends keyof this>(keyname: K): this[K];
        get(keyName: string): unknown;
        set<K extends keyof Content>(keyName: K, value: Content[K]): Content[K];
        set<K extends keyof this>(keyName: K, value: this[K]): this[K];
        set(keyName: string): unknown;
        getProperties<K extends keyof Content | keyof this>(list: K[]): Pick<Content, Exclude<K, keyof this>> & Pick<this, Exclude<K, keyof Content>>;
        getProperties<K extends keyof Content | keyof this>(...list: K[]): Pick<Content, Exclude<K, keyof this>> & Pick<this, Exclude<K, keyof Content>>;
        getProperties<K extends string>(list: K[]): Record<K, unknown>;
        getProperties<K extends string>(...list: K[]): Record<K, unknown>;
        setProperties<K extends keyof Content | keyof this, Hash extends Partial<Pick<Content, Exclude<K, keyof this>> & Pick<this, Exclude<K, keyof Content>>>>(hash: Hash): Hash;
        setProperties<T extends Record<string, unknown>>(hash: T): T;
    }
    class ObjectProxy<Content = unknown> extends FrameworkObject {
    }
    export default ObjectProxy;
}